Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include "unocontroltablemodel.hxx"
21 : #include "unogridcolumnfacade.hxx"
22 :
23 : #include "table/defaultinputhandler.hxx"
24 : #include "table/gridtablerenderer.hxx"
25 : #include "table/tablecontrol.hxx"
26 :
27 : #include <com/sun/star/awt/grid/XGridColumn.hpp>
28 : #include <com/sun/star/view/SelectionType.hpp>
29 : #include <com/sun/star/awt/grid/XGridColumnListener.hpp>
30 : #include <com/sun/star/awt/grid/XSortableGridData.hpp>
31 :
32 : #include <cppuhelper/weakref.hxx>
33 : #include <tools/debug.hxx>
34 : #include <tools/diagnose_ex.h>
35 : #include <vcl/svapp.hxx>
36 : #include <osl/mutex.hxx>
37 :
38 :
39 : namespace svt { namespace table
40 : {
41 :
42 :
43 : using ::com::sun::star::uno::Reference;
44 : using ::com::sun::star::uno::RuntimeException;
45 : using ::com::sun::star::uno::Sequence;
46 : using ::com::sun::star::uno::UNO_QUERY_THROW;
47 : using ::com::sun::star::uno::UNO_QUERY;
48 : using ::com::sun::star::awt::grid::XGridColumn;
49 : using ::com::sun::star::uno::XInterface;
50 : using ::com::sun::star::uno::Exception;
51 : using ::com::sun::star::awt::grid::XGridColumnListener;
52 : using ::com::sun::star::lang::EventObject;
53 : using ::com::sun::star::awt::grid::GridColumnEvent;
54 : using ::com::sun::star::awt::grid::XGridDataModel;
55 : using ::com::sun::star::awt::grid::XGridColumnModel;
56 : using ::com::sun::star::uno::Any;
57 : using ::com::sun::star::style::HorizontalAlignment_LEFT;
58 : using ::com::sun::star::style::HorizontalAlignment;
59 : using ::com::sun::star::style::VerticalAlignment_TOP;
60 : using ::com::sun::star::style::VerticalAlignment;
61 : using ::com::sun::star::uno::WeakReference;
62 : using ::com::sun::star::awt::grid::GridDataEvent;
63 : using ::com::sun::star::awt::grid::XSortableGridData;
64 : using ::com::sun::star::beans::Pair;
65 :
66 :
67 : //= UnoControlTableModel_Impl
68 :
69 : typedef ::std::vector< PTableModelListener > ModellListeners;
70 : typedef ::std::vector< PColumnModel > ColumnModels;
71 1 : struct UnoControlTableModel_Impl
72 : {
73 : ColumnModels aColumns;
74 : bool bHasColumnHeaders;
75 : bool bHasRowHeaders;
76 : ScrollbarVisibility eVScrollMode;
77 : ScrollbarVisibility eHScrollMode;
78 : PTableRenderer pRenderer;
79 : PTableInputHandler pInputHandler;
80 : TableMetrics nRowHeight;
81 : TableMetrics nColumnHeaderHeight;
82 : TableMetrics nRowHeaderWidth;
83 : ::boost::optional< ::Color > m_aGridLineColor;
84 : ::boost::optional< ::Color > m_aHeaderBackgroundColor;
85 : ::boost::optional< ::Color > m_aHeaderTextColor;
86 : ::boost::optional< ::Color > m_aActiveSelectionBackColor;
87 : ::boost::optional< ::Color > m_aInactiveSelectionBackColor;
88 : ::boost::optional< ::Color > m_aActiveSelectionTextColor;
89 : ::boost::optional< ::Color > m_aInactiveSelectionTextColor;
90 : ::boost::optional< ::Color > m_aTextColor;
91 : ::boost::optional< ::Color > m_aTextLineColor;
92 : ::boost::optional< ::std::vector< ::Color > > m_aRowColors;
93 : VerticalAlignment m_eVerticalAlign;
94 : bool bEnabled;
95 : ModellListeners m_aListeners;
96 : WeakReference< XGridDataModel > m_aDataModel;
97 : WeakReference< XGridColumnModel > m_aColumnModel;
98 :
99 1 : UnoControlTableModel_Impl()
100 : :aColumns ( )
101 : ,bHasColumnHeaders ( true )
102 : ,bHasRowHeaders ( false )
103 : ,eVScrollMode ( ScrollbarShowNever )
104 : ,eHScrollMode ( ScrollbarShowNever )
105 : ,pRenderer ( )
106 : ,pInputHandler ( )
107 : ,nRowHeight ( 10 )
108 : ,nColumnHeaderHeight ( 10 )
109 : ,nRowHeaderWidth ( 10 )
110 : ,m_aGridLineColor ( )
111 : ,m_aHeaderBackgroundColor ( )
112 : ,m_aHeaderTextColor ( )
113 : ,m_aActiveSelectionBackColor ( )
114 : ,m_aInactiveSelectionBackColor ( )
115 : ,m_aActiveSelectionTextColor ( )
116 : ,m_aInactiveSelectionTextColor ( )
117 : ,m_aTextColor ( )
118 : ,m_aTextLineColor ( )
119 : ,m_aRowColors ( )
120 : ,m_eVerticalAlign ( VerticalAlignment_TOP )
121 1 : ,bEnabled ( true )
122 : {
123 1 : }
124 : };
125 :
126 : //= UnoControlTableModel
127 : #define DBG_CHECK_ME() \
128 : DBG_TESTSOLARMUTEX(); \
129 :
130 1 : UnoControlTableModel::UnoControlTableModel()
131 1 : :m_pImpl( new UnoControlTableModel_Impl )
132 : {
133 1 : m_pImpl->bHasColumnHeaders = true;
134 1 : m_pImpl->bHasRowHeaders = false;
135 1 : m_pImpl->bEnabled = true;
136 1 : m_pImpl->pRenderer.reset( new GridTableRenderer( *this ) );
137 1 : m_pImpl->pInputHandler.reset( new DefaultInputHandler );
138 1 : }
139 :
140 :
141 3 : UnoControlTableModel::~UnoControlTableModel()
142 : {
143 1 : DELETEZ( m_pImpl );
144 2 : }
145 :
146 :
147 155 : TableSize UnoControlTableModel::getColumnCount() const
148 : {
149 : DBG_CHECK_ME();
150 155 : return (TableSize)m_pImpl->aColumns.size();
151 : }
152 :
153 :
154 23 : TableSize UnoControlTableModel::getRowCount() const
155 : {
156 : DBG_CHECK_ME();
157 :
158 23 : TableSize nRowCount = 0;
159 : try
160 : {
161 23 : Reference< XGridDataModel > const xDataModel( m_pImpl->m_aDataModel );
162 23 : ENSURE_OR_THROW( xDataModel.is(), "no data model anymore!" );
163 23 : nRowCount = xDataModel->getRowCount();
164 : }
165 0 : catch( const Exception& )
166 : {
167 : DBG_UNHANDLED_EXCEPTION();
168 : }
169 23 : return nRowCount;
170 : }
171 :
172 :
173 6 : bool UnoControlTableModel::hasColumnHeaders() const
174 : {
175 : DBG_CHECK_ME();
176 6 : return m_pImpl->bHasColumnHeaders;
177 : }
178 :
179 :
180 31 : bool UnoControlTableModel::hasRowHeaders() const
181 : {
182 : DBG_CHECK_ME();
183 31 : return m_pImpl->bHasRowHeaders;
184 : }
185 :
186 :
187 1 : void UnoControlTableModel::setRowHeaders(bool _bRowHeaders)
188 : {
189 : DBG_CHECK_ME();
190 1 : if ( m_pImpl->bHasRowHeaders == _bRowHeaders )
191 2 : return;
192 :
193 0 : m_pImpl->bHasRowHeaders = _bRowHeaders;
194 0 : impl_notifyTableMetricsChanged();
195 : }
196 :
197 :
198 1 : void UnoControlTableModel::setColumnHeaders(bool _bColumnHeaders)
199 : {
200 : DBG_CHECK_ME();
201 1 : if ( m_pImpl->bHasColumnHeaders == _bColumnHeaders )
202 2 : return;
203 :
204 0 : m_pImpl->bHasColumnHeaders = _bColumnHeaders;
205 0 : impl_notifyTableMetricsChanged();
206 : }
207 :
208 :
209 0 : bool UnoControlTableModel::isCellEditable( ColPos col, RowPos row ) const
210 : {
211 : DBG_CHECK_ME();
212 : (void)col;
213 : (void)row;
214 0 : return false;
215 : }
216 :
217 :
218 84 : PColumnModel UnoControlTableModel::getColumnModel( ColPos column )
219 : {
220 : DBG_CHECK_ME();
221 84 : ENSURE_OR_RETURN( ( column >= 0 ) && ( column < getColumnCount() ),
222 : "DefaultTableModel::getColumnModel: invalid index!", PColumnModel() );
223 84 : return m_pImpl->aColumns[ column ];
224 : }
225 :
226 :
227 0 : void UnoControlTableModel::appendColumn( Reference< XGridColumn > const & i_column )
228 : {
229 : DBG_CHECK_ME();
230 0 : insertColumn( m_pImpl->aColumns.size(), i_column );
231 0 : }
232 :
233 :
234 3 : void UnoControlTableModel::insertColumn( ColPos const i_position, Reference< XGridColumn > const & i_column )
235 : {
236 : DBG_CHECK_ME();
237 6 : ENSURE_OR_RETURN_VOID( ( i_position >= 0 ) && ( size_t( i_position ) <= m_pImpl->aColumns.size() ),
238 : "UnoControlTableModel::insertColumn: illegal position!" );
239 :
240 3 : const PColumnModel pColumn( new UnoGridColumnFacade( *this, i_column ) );
241 3 : m_pImpl->aColumns.insert( m_pImpl->aColumns.begin() + i_position, pColumn );
242 :
243 : // notify listeners
244 6 : ModellListeners aListeners( m_pImpl->m_aListeners );
245 18 : for ( ModellListeners::const_iterator loop = aListeners.begin();
246 12 : loop != aListeners.end();
247 : ++loop
248 : )
249 : {
250 3 : (*loop)->columnInserted( i_position );
251 3 : }
252 : }
253 :
254 :
255 1 : void UnoControlTableModel::removeColumn( ColPos const i_position )
256 : {
257 : DBG_CHECK_ME();
258 2 : ENSURE_OR_RETURN_VOID( ( i_position >= 0 ) && ( size_t( i_position ) <= m_pImpl->aColumns.size() ),
259 : "UnoControlTableModel::removeColumn: illegal position!" );
260 :
261 : // remove the column
262 1 : ColumnModels::iterator pos = m_pImpl->aColumns.begin() + i_position;
263 1 : const PColumnModel pColumn = *pos;
264 1 : m_pImpl->aColumns.erase( pos );
265 :
266 : // notify listeners
267 2 : ModellListeners aListeners( m_pImpl->m_aListeners );
268 6 : for ( ModellListeners::const_iterator loop = aListeners.begin();
269 4 : loop != aListeners.end();
270 : ++loop
271 : )
272 : {
273 1 : (*loop)->columnRemoved( i_position );
274 : }
275 :
276 : // dispose the column
277 1 : UnoGridColumnFacade* pColumnImpl = dynamic_cast< UnoGridColumnFacade* >( pColumn.get() );
278 : OSL_ENSURE( pColumnImpl != NULL, "UnoControlTableModel::removeColumn: illegal column implementation!" );
279 1 : if ( pColumnImpl )
280 2 : pColumnImpl->dispose();
281 : }
282 :
283 :
284 1 : void UnoControlTableModel::removeAllColumns()
285 : {
286 : DBG_CHECK_ME();
287 1 : if ( m_pImpl->aColumns.empty() )
288 2 : return;
289 :
290 : // dispose the column instances
291 0 : for ( ColumnModels::const_iterator col = m_pImpl->aColumns.begin();
292 0 : col != m_pImpl->aColumns.end();
293 : ++col
294 : )
295 : {
296 0 : UnoGridColumnFacade* pColumn = dynamic_cast< UnoGridColumnFacade* >( col->get() );
297 0 : if ( !pColumn )
298 : {
299 : SAL_WARN( "svtools.uno", "UnoControlTableModel::removeAllColumns: illegal column implementation!" );
300 0 : continue;
301 : }
302 :
303 0 : pColumn->dispose();
304 : }
305 0 : m_pImpl->aColumns.clear();
306 :
307 : // notify listeners
308 0 : ModellListeners aListeners( m_pImpl->m_aListeners );
309 0 : for ( ModellListeners::const_iterator loop = aListeners.begin();
310 0 : loop != aListeners.end();
311 : ++loop
312 : )
313 : {
314 0 : (*loop)->allColumnsRemoved();
315 0 : }
316 : }
317 :
318 :
319 0 : void UnoControlTableModel::impl_notifyTableMetricsChanged() const
320 : {
321 0 : ModellListeners aListeners( m_pImpl->m_aListeners );
322 0 : for ( ModellListeners::const_iterator loop = aListeners.begin();
323 0 : loop != aListeners.end();
324 : ++loop
325 : )
326 : {
327 0 : (*loop)->tableMetricsChanged();
328 0 : }
329 0 : }
330 :
331 :
332 6 : PTableRenderer UnoControlTableModel::getRenderer() const
333 : {
334 : DBG_CHECK_ME();
335 6 : return m_pImpl->pRenderer;
336 : }
337 :
338 :
339 1 : PTableInputHandler UnoControlTableModel::getInputHandler() const
340 : {
341 : DBG_CHECK_ME();
342 1 : return m_pImpl->pInputHandler;
343 : }
344 :
345 :
346 1 : TableMetrics UnoControlTableModel::getRowHeight() const
347 : {
348 : DBG_CHECK_ME();
349 1 : return m_pImpl->nRowHeight;
350 : }
351 :
352 :
353 1 : void UnoControlTableModel::setRowHeight(TableMetrics _nRowHeight)
354 : {
355 : DBG_CHECK_ME();
356 1 : if ( m_pImpl->nRowHeight == _nRowHeight )
357 2 : return;
358 :
359 0 : m_pImpl->nRowHeight = _nRowHeight;
360 0 : impl_notifyTableMetricsChanged();
361 : }
362 :
363 :
364 1 : TableMetrics UnoControlTableModel::getColumnHeaderHeight() const
365 : {
366 : DBG_CHECK_ME();
367 : DBG_ASSERT( hasColumnHeaders(), "DefaultTableModel::getColumnHeaderHeight: invalid call!" );
368 1 : return m_pImpl->nColumnHeaderHeight;
369 : }
370 :
371 :
372 0 : TableMetrics UnoControlTableModel::getRowHeaderWidth() const
373 : {
374 : DBG_CHECK_ME();
375 : DBG_ASSERT( hasRowHeaders(), "DefaultTableModel::getRowHeaderWidth: invalid call!" );
376 0 : return m_pImpl->nRowHeaderWidth;
377 : }
378 :
379 1 : void UnoControlTableModel::setColumnHeaderHeight(TableMetrics _nHeight)
380 : {
381 : DBG_CHECK_ME();
382 1 : if ( m_pImpl->nColumnHeaderHeight == _nHeight )
383 2 : return;
384 :
385 0 : m_pImpl->nColumnHeaderHeight = _nHeight;
386 0 : impl_notifyTableMetricsChanged();
387 : }
388 :
389 :
390 1 : void UnoControlTableModel::setRowHeaderWidth(TableMetrics _nWidth)
391 : {
392 : DBG_CHECK_ME();
393 1 : if ( m_pImpl->nRowHeaderWidth == _nWidth )
394 2 : return;
395 :
396 0 : m_pImpl->nRowHeaderWidth = _nWidth;
397 0 : impl_notifyTableMetricsChanged();
398 : }
399 :
400 :
401 20 : ScrollbarVisibility UnoControlTableModel::getVerticalScrollbarVisibility() const
402 : {
403 : DBG_CHECK_ME();
404 20 : return m_pImpl->eVScrollMode;
405 : }
406 :
407 :
408 10 : ScrollbarVisibility UnoControlTableModel::getHorizontalScrollbarVisibility() const
409 : {
410 : DBG_CHECK_ME();
411 10 : return m_pImpl->eHScrollMode;
412 : }
413 :
414 :
415 1 : void UnoControlTableModel::addTableModelListener( const PTableModelListener& i_listener )
416 : {
417 : DBG_CHECK_ME();
418 2 : ENSURE_OR_RETURN_VOID( !!i_listener, "illegal NULL listener" );
419 1 : m_pImpl->m_aListeners.push_back( i_listener );
420 : }
421 :
422 :
423 1 : void UnoControlTableModel::removeTableModelListener( const PTableModelListener& i_listener )
424 : {
425 : DBG_CHECK_ME();
426 3 : for ( ModellListeners::iterator lookup = m_pImpl->m_aListeners.begin();
427 2 : lookup != m_pImpl->m_aListeners.end();
428 : ++lookup
429 : )
430 : {
431 1 : if ( *lookup == i_listener )
432 : {
433 1 : m_pImpl->m_aListeners.erase( lookup );
434 2 : return;
435 : }
436 : }
437 : OSL_ENSURE( false, "UnoControlTableModel::removeTableModelListener: listener is not registered - sure you're doing the right thing here?" );
438 : }
439 :
440 :
441 1 : void UnoControlTableModel::setVerticalScrollbarVisibility( ScrollbarVisibility const i_visibility ) const
442 : {
443 : DBG_CHECK_ME();
444 1 : m_pImpl->eVScrollMode = i_visibility;
445 1 : }
446 :
447 :
448 1 : void UnoControlTableModel::setHorizontalScrollbarVisibility( ScrollbarVisibility const i_visibility ) const
449 : {
450 : DBG_CHECK_ME();
451 1 : m_pImpl->eHScrollMode = i_visibility;
452 1 : }
453 :
454 :
455 1 : void UnoControlTableModel::setDataModel( Reference< XGridDataModel > const & i_gridDataModel )
456 : {
457 : DBG_CHECK_ME();
458 1 : m_pImpl->m_aDataModel = i_gridDataModel;
459 : // TODO: register as listener, so we're notified of row/data changes, and can multiplex them to our
460 : // own listeners
461 1 : }
462 :
463 :
464 13 : Reference< XGridDataModel > UnoControlTableModel::getDataModel() const
465 : {
466 13 : Reference< XGridDataModel > const xDataModel( m_pImpl->m_aDataModel );
467 13 : return xDataModel;
468 : }
469 :
470 :
471 2 : bool UnoControlTableModel::hasDataModel() const
472 : {
473 2 : return getDataModel().is();
474 : }
475 :
476 :
477 1 : void UnoControlTableModel::setColumnModel( Reference< XGridColumnModel > const & i_gridColumnModel )
478 : {
479 : DBG_CHECK_ME();
480 1 : m_pImpl->m_aColumnModel = i_gridColumnModel;
481 1 : }
482 :
483 :
484 5 : Reference< XGridColumnModel > UnoControlTableModel::getColumnModel() const
485 : {
486 5 : Reference< XGridColumnModel > const xColumnModel( m_pImpl->m_aColumnModel );
487 5 : return xColumnModel;
488 : }
489 :
490 :
491 3 : bool UnoControlTableModel::hasColumnModel() const
492 : {
493 3 : return getColumnModel().is();
494 : }
495 :
496 :
497 13 : void UnoControlTableModel::getCellContent( ColPos const i_col, RowPos const i_row, Any& o_cellContent )
498 : {
499 : DBG_CHECK_ME();
500 :
501 13 : o_cellContent.clear();
502 : try
503 : {
504 13 : Reference< XGridDataModel > const xDataModel( m_pImpl->m_aDataModel );
505 13 : ENSURE_OR_RETURN_VOID( xDataModel.is(), "UnoControlTableModel::getCellContent: no data model anymore!" );
506 :
507 26 : PColumnModel const pColumn = getColumnModel( i_col );
508 13 : UnoGridColumnFacade* pColumnImpl = dynamic_cast< UnoGridColumnFacade* >( pColumn.get() );
509 13 : ENSURE_OR_RETURN_VOID( pColumnImpl != NULL, "UnoControlTableModel::getCellContent: no (valid) column at this position!" );
510 13 : sal_Int32 const nDataColumnIndex = pColumnImpl->getDataColumnIndex() >= 0 ? pColumnImpl->getDataColumnIndex() : i_col;
511 :
512 13 : if ( nDataColumnIndex >= xDataModel->getColumnCount() )
513 : {
514 : // this is allowed, in case the column model has been dynamically extended, but the data model does
515 : // not (yet?) know about it.
516 : // So, handle it gracefully.
517 : #if OSL_DEBUG_LEVEL > 0
518 : {
519 : Reference< XGridColumnModel > const xColumnModel( m_pImpl->m_aColumnModel );
520 : OSL_ENSURE( xColumnModel.is() && i_col < xColumnModel->getColumnCount(),
521 : "UnoControlTableModel::getCellContent: request a column's value which the ColumnModel doesn't know about!" );
522 : }
523 : #endif
524 : }
525 : else
526 : {
527 13 : o_cellContent = xDataModel->getCellData( nDataColumnIndex, i_row );
528 13 : }
529 : }
530 0 : catch( const Exception& )
531 : {
532 : DBG_UNHANDLED_EXCEPTION();
533 : }
534 : }
535 :
536 :
537 0 : void UnoControlTableModel::getCellToolTip( ColPos const i_col, RowPos const i_row, Any& o_cellToolTip )
538 : {
539 : DBG_CHECK_ME();
540 : try
541 : {
542 0 : Reference< XGridDataModel > const xDataModel( m_pImpl->m_aDataModel );
543 0 : ENSURE_OR_THROW( xDataModel.is(), "no data model anymore!" );
544 :
545 0 : o_cellToolTip = xDataModel->getCellToolTip( i_col, i_row );
546 : }
547 0 : catch( const Exception& )
548 : {
549 : DBG_UNHANDLED_EXCEPTION();
550 : }
551 0 : }
552 :
553 :
554 0 : Any UnoControlTableModel::getRowHeading( RowPos const i_rowPos ) const
555 : {
556 : DBG_CHECK_ME();
557 :
558 0 : Any aRowHeading;
559 :
560 0 : Reference< XGridDataModel > const xDataModel( m_pImpl->m_aDataModel );
561 0 : ENSURE_OR_RETURN( xDataModel.is(), "UnoControlTableModel::getRowHeading: no data model anymore!", aRowHeading );
562 :
563 : try
564 : {
565 0 : aRowHeading = xDataModel->getRowHeading( i_rowPos );
566 : }
567 0 : catch( const Exception& )
568 : {
569 : DBG_UNHANDLED_EXCEPTION();
570 : }
571 0 : return aRowHeading;
572 : }
573 :
574 :
575 : namespace
576 : {
577 9 : void lcl_setColor( Any const & i_color, ::boost::optional< ::Color > & o_convertedColor )
578 : {
579 9 : if ( !i_color.hasValue() )
580 9 : o_convertedColor.reset();
581 : else
582 : {
583 0 : sal_Int32 nColor = COL_TRANSPARENT;
584 0 : if ( i_color >>= nColor )
585 : {
586 0 : o_convertedColor.reset( ::Color( nColor ) );
587 : }
588 : else
589 : {
590 : OSL_ENSURE( false, "lcl_setColor: could not extract color value!" );
591 : }
592 : }
593 9 : }
594 : }
595 :
596 :
597 15 : ::boost::optional< ::Color > UnoControlTableModel::getLineColor() const
598 : {
599 : DBG_CHECK_ME();
600 15 : return m_pImpl->m_aGridLineColor;
601 : }
602 :
603 :
604 1 : void UnoControlTableModel::setLineColor( Any const & i_color )
605 : {
606 : DBG_CHECK_ME();
607 1 : lcl_setColor( i_color, m_pImpl->m_aGridLineColor );
608 1 : }
609 :
610 :
611 5 : ::boost::optional< ::Color > UnoControlTableModel::getHeaderBackgroundColor() const
612 : {
613 : DBG_CHECK_ME();
614 5 : return m_pImpl->m_aHeaderBackgroundColor;
615 : }
616 :
617 :
618 1 : void UnoControlTableModel::setHeaderBackgroundColor( Any const & i_color )
619 : {
620 : DBG_CHECK_ME();
621 1 : lcl_setColor( i_color, m_pImpl->m_aHeaderBackgroundColor );
622 1 : }
623 :
624 :
625 0 : ::boost::optional< ::Color > UnoControlTableModel::getHeaderTextColor() const
626 : {
627 : DBG_CHECK_ME();
628 0 : return m_pImpl->m_aHeaderTextColor;
629 : }
630 :
631 :
632 5 : ::boost::optional< ::Color > UnoControlTableModel::getActiveSelectionBackColor() const
633 : {
634 : DBG_CHECK_ME();
635 5 : return m_pImpl->m_aActiveSelectionBackColor;
636 : }
637 :
638 :
639 0 : ::boost::optional< ::Color > UnoControlTableModel::getInactiveSelectionBackColor() const
640 : {
641 : DBG_CHECK_ME();
642 0 : return m_pImpl->m_aInactiveSelectionBackColor;
643 : }
644 :
645 :
646 0 : ::boost::optional< ::Color > UnoControlTableModel::getActiveSelectionTextColor() const
647 : {
648 : DBG_CHECK_ME();
649 0 : return m_pImpl->m_aActiveSelectionTextColor;
650 : }
651 :
652 :
653 0 : ::boost::optional< ::Color > UnoControlTableModel::getInactiveSelectionTextColor() const
654 : {
655 : DBG_CHECK_ME();
656 0 : return m_pImpl->m_aInactiveSelectionTextColor;
657 : }
658 :
659 :
660 1 : void UnoControlTableModel::setHeaderTextColor( Any const & i_color )
661 : {
662 : DBG_CHECK_ME();
663 1 : lcl_setColor( i_color, m_pImpl->m_aHeaderTextColor );
664 1 : }
665 :
666 :
667 1 : void UnoControlTableModel::setActiveSelectionBackColor( Any const & i_color )
668 : {
669 : DBG_CHECK_ME();
670 1 : lcl_setColor( i_color, m_pImpl->m_aActiveSelectionBackColor );
671 1 : }
672 :
673 :
674 1 : void UnoControlTableModel::setInactiveSelectionBackColor( Any const & i_color )
675 : {
676 : DBG_CHECK_ME();
677 1 : lcl_setColor( i_color, m_pImpl->m_aInactiveSelectionBackColor );
678 1 : }
679 :
680 :
681 1 : void UnoControlTableModel::setActiveSelectionTextColor( Any const & i_color )
682 : {
683 : DBG_CHECK_ME();
684 1 : lcl_setColor( i_color, m_pImpl->m_aActiveSelectionTextColor );
685 1 : }
686 :
687 :
688 1 : void UnoControlTableModel::setInactiveSelectionTextColor( Any const & i_color )
689 : {
690 : DBG_CHECK_ME();
691 1 : lcl_setColor( i_color, m_pImpl->m_aInactiveSelectionTextColor );
692 1 : }
693 :
694 :
695 18 : ::boost::optional< ::Color > UnoControlTableModel::getTextColor() const
696 : {
697 : DBG_CHECK_ME();
698 18 : return m_pImpl->m_aTextColor;
699 : }
700 :
701 :
702 1 : void UnoControlTableModel::setTextColor( Any const & i_color )
703 : {
704 : DBG_CHECK_ME();
705 1 : lcl_setColor( i_color, m_pImpl->m_aTextColor );
706 1 : }
707 :
708 :
709 0 : ::boost::optional< ::Color > UnoControlTableModel::getTextLineColor() const
710 : {
711 : DBG_CHECK_ME();
712 0 : return m_pImpl->m_aTextColor;
713 : }
714 :
715 :
716 1 : void UnoControlTableModel::setTextLineColor( Any const & i_color )
717 : {
718 : DBG_CHECK_ME();
719 1 : lcl_setColor( i_color, m_pImpl->m_aTextLineColor );
720 1 : }
721 :
722 :
723 5 : ::boost::optional< ::std::vector< ::Color > > UnoControlTableModel::getRowBackgroundColors() const
724 : {
725 : DBG_CHECK_ME();
726 5 : return m_pImpl->m_aRowColors;
727 : }
728 :
729 :
730 1 : void UnoControlTableModel::setRowBackgroundColors( ::com::sun::star::uno::Any const & i_APIValue )
731 : {
732 : DBG_CHECK_ME();
733 1 : Sequence< ::com::sun::star::util::Color > aAPIColors;
734 1 : if ( !( i_APIValue >>= aAPIColors ) )
735 1 : m_pImpl->m_aRowColors.reset();
736 : else
737 : {
738 0 : ::std::vector< ::Color > aColors( aAPIColors.getLength() );
739 0 : for ( sal_Int32 i=0; i<aAPIColors.getLength(); ++i )
740 : {
741 0 : aColors[i] = ::Color( aAPIColors[i] );
742 : }
743 0 : m_pImpl->m_aRowColors.reset( aColors );
744 1 : }
745 1 : }
746 :
747 :
748 18 : VerticalAlignment UnoControlTableModel::getVerticalAlign() const
749 : {
750 : DBG_CHECK_ME();
751 18 : return m_pImpl->m_eVerticalAlign;
752 : }
753 :
754 :
755 0 : void UnoControlTableModel::setVerticalAlign( VerticalAlignment _xAlign )
756 : {
757 : DBG_CHECK_ME();
758 0 : m_pImpl->m_eVerticalAlign = _xAlign;
759 0 : }
760 :
761 :
762 8 : ColPos UnoControlTableModel::getColumnPos( UnoGridColumnFacade const & i_column ) const
763 : {
764 : DBG_CHECK_ME();
765 39 : for ( ColumnModels::const_iterator col = m_pImpl->aColumns.begin();
766 26 : col != m_pImpl->aColumns.end();
767 : ++col
768 : )
769 : {
770 13 : if ( &i_column == col->get() )
771 8 : return col - m_pImpl->aColumns.begin();
772 : }
773 : OSL_ENSURE( false, "UnoControlTableModel::getColumnPos: column not found!" );
774 0 : return COL_INVALID;
775 : }
776 :
777 :
778 5 : ITableDataSort* UnoControlTableModel::getSortAdapter()
779 : {
780 : DBG_CHECK_ME();
781 :
782 5 : Reference< XSortableGridData > const xSortAccess( getDataModel(), UNO_QUERY );
783 5 : if ( xSortAccess.is() )
784 5 : return this;
785 0 : return NULL;
786 : }
787 :
788 :
789 18 : bool UnoControlTableModel::isEnabled() const
790 : {
791 : DBG_CHECK_ME();
792 18 : return m_pImpl->bEnabled;
793 : }
794 :
795 :
796 1 : void UnoControlTableModel::setEnabled( bool _bEnabled )
797 : {
798 : DBG_CHECK_ME();
799 1 : m_pImpl->bEnabled = _bEnabled;
800 1 : }
801 :
802 :
803 0 : void UnoControlTableModel::sortByColumn( ColPos const i_column, ColumnSortDirection const i_sortDirection )
804 : {
805 : DBG_CHECK_ME();
806 :
807 : try
808 : {
809 0 : Reference< XSortableGridData > const xSortAccess( getDataModel(), UNO_QUERY_THROW );
810 0 : xSortAccess->sortByColumn( i_column, i_sortDirection == ColumnSortAscending );
811 : }
812 0 : catch( const Exception& )
813 : {
814 : DBG_UNHANDLED_EXCEPTION();
815 : }
816 0 : }
817 :
818 :
819 5 : ColumnSort UnoControlTableModel::getCurrentSortOrder() const
820 : {
821 : DBG_CHECK_ME();
822 :
823 5 : ColumnSort currentSort;
824 : try
825 : {
826 5 : Reference< XSortableGridData > const xSortAccess( getDataModel(), UNO_QUERY_THROW );
827 5 : Pair< ::sal_Int32, sal_Bool > const aCurrentSortOrder( xSortAccess->getCurrentSortOrder() );
828 5 : currentSort.nColumnPos = aCurrentSortOrder.First;
829 5 : currentSort.eSortDirection = aCurrentSortOrder.Second ? ColumnSortAscending : ColumnSortDescending;
830 : }
831 0 : catch( const Exception& )
832 : {
833 : DBG_UNHANDLED_EXCEPTION();
834 : }
835 5 : return currentSort;
836 : }
837 :
838 :
839 8 : void UnoControlTableModel::notifyColumnChange( ColPos const i_columnPos, ColumnAttributeGroup const i_attributeGroup ) const
840 : {
841 : DBG_CHECK_ME();
842 16 : ENSURE_OR_RETURN_VOID( ( i_columnPos >= 0 ) && ( i_columnPos < getColumnCount() ),
843 : "UnoControlTableModel::notifyColumnChange: invalid column index!" );
844 :
845 8 : ModellListeners aListeners( m_pImpl->m_aListeners );
846 48 : for ( ModellListeners::const_iterator loop = aListeners.begin();
847 32 : loop != aListeners.end();
848 : ++loop
849 : )
850 : {
851 8 : (*loop)->columnChanged( i_columnPos, i_attributeGroup );
852 8 : }
853 : }
854 :
855 :
856 2 : void UnoControlTableModel::notifyRowsInserted( GridDataEvent const & i_event ) const
857 : {
858 : // check sanity of the event
859 2 : ENSURE_OR_RETURN_VOID( i_event.FirstRow >= 0, "UnoControlTableModel::notifyRowsInserted: invalid first row!" );
860 2 : ENSURE_OR_RETURN_VOID( i_event.LastRow >= i_event.FirstRow, "UnoControlTableModel::notifyRowsInserted: invalid row indexes!" );
861 :
862 : // check own sanity
863 2 : Reference< XGridColumnModel > const xColumnModel( m_pImpl->m_aColumnModel );
864 2 : ENSURE_OR_RETURN_VOID( xColumnModel.is(), "UnoControlTableModel::notifyRowsInserted: no column model anymore!" );
865 :
866 4 : Reference< XGridDataModel > const xDataModel( m_pImpl->m_aDataModel );
867 2 : ENSURE_OR_RETURN_VOID( xDataModel.is(), "UnoControlTableModel::notifyRowsInserted: no data model anymore!" );
868 :
869 : // implicitly add columns to the column model
870 : // TODO: is this really a good idea?
871 2 : sal_Int32 const dataColumnCount = xDataModel->getColumnCount();
872 : OSL_ENSURE( dataColumnCount > 0, "UnoControlTableModel::notifyRowsInserted: no columns at all?" );
873 :
874 2 : sal_Int32 const modelColumnCount = xColumnModel->getColumnCount();
875 2 : if ( ( modelColumnCount == 0 ) && ( dataColumnCount > 0 ) )
876 : {
877 : // TODO: shouldn't we clear the mutexes guard for this call?
878 1 : xColumnModel->setDefaultColumns( dataColumnCount );
879 : }
880 :
881 : // multiplex the event to our own listeners
882 4 : ModellListeners aListeners( m_pImpl->m_aListeners );
883 12 : for ( ModellListeners::const_iterator loop = aListeners.begin();
884 8 : loop != aListeners.end();
885 : ++loop
886 : )
887 : {
888 2 : (*loop)->rowsInserted( i_event.FirstRow, i_event.LastRow );
889 2 : }
890 : }
891 :
892 :
893 1 : void UnoControlTableModel::notifyRowsRemoved( GridDataEvent const & i_event ) const
894 : {
895 1 : ModellListeners aListeners( m_pImpl->m_aListeners );
896 6 : for ( ModellListeners::const_iterator loop = aListeners.begin();
897 4 : loop != aListeners.end();
898 : ++loop
899 : )
900 : {
901 1 : (*loop)->rowsRemoved( i_event.FirstRow, i_event.LastRow );
902 1 : }
903 1 : }
904 :
905 :
906 0 : void UnoControlTableModel::notifyDataChanged( ::com::sun::star::awt::grid::GridDataEvent const & i_event ) const
907 : {
908 0 : ColPos const firstCol = i_event.FirstColumn == -1 ? 0 : i_event.FirstColumn;
909 0 : ColPos const lastCol = i_event.FirstColumn == -1 ? getColumnCount() - 1 : i_event.LastColumn;
910 0 : RowPos const firstRow = i_event.FirstRow == -1 ? 0 : i_event.FirstRow;
911 0 : RowPos const lastRow = i_event.FirstRow == -1 ? getRowCount() - 1 : i_event.LastRow;
912 :
913 0 : ModellListeners aListeners( m_pImpl->m_aListeners );
914 0 : for ( ModellListeners::const_iterator loop = aListeners.begin();
915 0 : loop != aListeners.end();
916 : ++loop
917 : )
918 : {
919 0 : (*loop)->cellsUpdated( firstCol, lastCol, firstRow, lastRow );
920 0 : }
921 0 : }
922 :
923 :
924 0 : void UnoControlTableModel::notifyAllDataChanged() const
925 : {
926 0 : ModellListeners aListeners( m_pImpl->m_aListeners );
927 0 : for ( ModellListeners::const_iterator loop = aListeners.begin();
928 0 : loop != aListeners.end();
929 : ++loop
930 : )
931 : {
932 0 : (*loop)->cellsUpdated( 0, getColumnCount() - 1, 0, getRowCount() - 1 );
933 0 : }
934 0 : }
935 :
936 :
937 : } } // svt::table
938 :
939 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
