?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update ooo320-m1
[ooovba.git] / sc / source / ui / dbgui / csvgrid.cxx
blob5725645100d338f6b3ff19cd023afae6ada0c55b
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: csvgrid.cxx,v $
10 * $Revision: 1.29 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_sc.hxx"
33
34
35 // ============================================================================
36 #include "csvgrid.hxx"
37
38 #include <algorithm>
39 #include <svtools/colorcfg.hxx>
40 #include <svtools/smplhint.hxx>
41 #include <tools/poly.hxx>
42 #include "scmod.hxx"
43 #include "asciiopt.hxx"
44 #include "impex.hxx"
45 #include "AccessibleCsvControl.hxx"
46
47 // *** edit engine ***
48 #include "scitems.hxx"
49 #include <svx/eeitem.hxx>
50
51
52 #include <svx/colritem.hxx>
53 #include <svx/fhgtitem.hxx>
54 #include <svx/fontitem.hxx>
55 #include <svtools/itemset.hxx>
56 #include "editutil.hxx"
57 // *** edit engine ***
58
59
60 // ============================================================================
61
62 struct Func_SetType
63 {
64 sal_Int32 mnType;
65 inline Func_SetType( sal_Int32 nType ) : mnType( nType ) {}
66 inline void operator()( ScCsvColState& rState ) { rState.mnType = mnType; }
67 };
68
69 struct Func_Select
70 {
71 bool mbSelect;
72 inline Func_Select( bool bSelect ) : mbSelect( bSelect ) {}
73 inline void operator()( ScCsvColState& rState ) { rState.Select( mbSelect ); }
74 };
75
76
77 // ============================================================================
78
79 ScCsvGrid::ScCsvGrid( ScCsvControl& rParent ) :
80 ScCsvControl( rParent ),
81 mrColorConfig( SC_MOD()->GetColorConfig() ),
82 mpEditEngine( new ScEditEngineDefaulter( EditEngine::CreatePool(), TRUE ) ),
83 maHeaderFont( GetFont() ),
84 maColStates( 1 ),
85 maTypeNames( 1 ),
86 mnFirstImpLine( 0 ),
87 mnRecentSelCol( CSV_COLUMN_INVALID )
88 {
89 mpEditEngine->SetRefDevice( &maBackgrDev );
90 mpEditEngine->SetRefMapMode( MapMode( MAP_PIXEL ) );
91 maEdEngSize = mpEditEngine->GetPaperSize();
92
93 maPopup.SetMenuFlags( maPopup.GetMenuFlags() | MENU_FLAG_NOAUTOMNEMONICS );
94
95 EnableRTL( false ); // #107812# RTL
96 InitColors();
97 InitFonts();
98 ImplClearSplits();
99 StartListening( mrColorConfig );
100 }
101
102 ScCsvGrid::~ScCsvGrid()
103 {
104 EndListening( mrColorConfig );
105 }
106
107
108 // common grid handling -------------------------------------------------------
109
110 void ScCsvGrid::UpdateLayoutData()
111 {
112 DisableRepaint();
113 SetFont( maMonoFont );
114 Execute( CSVCMD_SETCHARWIDTH, GetTextWidth( String( 'X' ) ) );
115 Execute( CSVCMD_SETLINEHEIGHT, GetTextHeight() + 1 );
116 SetFont( maHeaderFont );
117 Execute( CSVCMD_SETHDRHEIGHT, GetTextHeight() + 1 );
118 UpdateOffsetX();
119 EnableRepaint();
120 }
121
122 void ScCsvGrid::UpdateOffsetX()
123 {
124 sal_Int32 nLastLine = GetLastVisLine() + 1;
125 sal_Int32 nDigits = 2;
126 while( nLastLine /= 10 ) ++nDigits;
127 nDigits = Max( nDigits, sal_Int32( 3 ) );
128 Execute( CSVCMD_SETHDRWIDTH, GetTextWidth( String( '0' ) ) * nDigits );
129 }
130
131 void ScCsvGrid::ApplyLayout( const ScCsvLayoutData& rOldData )
132 {
133 ScCsvDiff nDiff = GetLayoutData().GetDiff( rOldData );
134 if( nDiff == CSV_DIFF_EQUAL ) return;
135
136 DisableRepaint();
137
138 if( nDiff & CSV_DIFF_RULERCURSOR )
139 {
140 ImplInvertCursor( rOldData.mnPosCursor );
141 ImplInvertCursor( GetRulerCursorPos() );
142 }
143
144 if( nDiff & CSV_DIFF_POSCOUNT )
145 {
146 if( GetPosCount() < rOldData.mnPosCount )
147 {
148 SelectAll( false );
149 maSplits.RemoveRange( GetPosCount(), rOldData.mnPosCount );
150 }
151 else
152 maSplits.Remove( rOldData.mnPosCount );
153 maSplits.Insert( GetPosCount() );
154 maColStates.resize( maSplits.Count() - 1 );
155 }
156
157 if( nDiff & CSV_DIFF_LINEOFFSET )
158 {
159 Execute( CSVCMD_UPDATECELLTEXTS );
160 UpdateOffsetX();
161 }
162
163 ScCsvDiff nHVDiff = nDiff & (CSV_DIFF_HORIZONTAL | CSV_DIFF_VERTICAL);
164 if( nHVDiff == CSV_DIFF_POSOFFSET )
165 ImplDrawHorzScrolled( rOldData.mnPosOffset );
166 else if( nHVDiff != CSV_DIFF_EQUAL )
167 InvalidateGfx();
168
169 EnableRepaint();
170
171 if( nDiff & (CSV_DIFF_POSOFFSET | CSV_DIFF_LINEOFFSET) )
172 AccSendVisibleEvent();
173 }
174
175 void ScCsvGrid::SetFirstImportedLine( sal_Int32 nLine )
176 {
177 ImplDrawFirstLineSep( false );
178 mnFirstImpLine = nLine;
179 ImplDrawFirstLineSep( true );
180 ImplDrawGridDev();
181 Repaint();
182 }
183
184 sal_Int32 ScCsvGrid::GetNoScrollCol( sal_Int32 nPos ) const
185 {
186 sal_Int32 nNewPos = nPos;
187 if( nNewPos != CSV_POS_INVALID )
188 {
189 if( nNewPos < GetFirstVisPos() + CSV_SCROLL_DIST )
190 {
191 sal_Int32 nScroll = (GetFirstVisPos() > 0) ? CSV_SCROLL_DIST : 0;
192 nNewPos = GetFirstVisPos() + nScroll;
193 }
194 else if( nNewPos > GetLastVisPos() - CSV_SCROLL_DIST - 1L )
195 {
196 sal_Int32 nScroll = (GetFirstVisPos() < GetMaxPosOffset()) ? CSV_SCROLL_DIST : 0;
197 nNewPos = GetLastVisPos() - nScroll - 1;
198 }
199 }
200 return nNewPos;
201 }
202
203 void ScCsvGrid::InitColors()
204 {
205 maBackColor.SetColor( static_cast< sal_uInt32 >( mrColorConfig.GetColorValue( ::svtools::DOCCOLOR ).nColor ) );
206 maGridColor.SetColor( static_cast< sal_uInt32 >( mrColorConfig.GetColorValue( ::svtools::CALCGRID ).nColor ) );
207 maGridPBColor.SetColor( static_cast< sal_uInt32 >( mrColorConfig.GetColorValue( ::svtools::CALCPAGEBREAK ).nColor ) );
208 maAppBackColor.SetColor( static_cast< sal_uInt32 >( mrColorConfig.GetColorValue( ::svtools::APPBACKGROUND ).nColor ) );
209 maTextColor.SetColor( static_cast< sal_uInt32 >( mrColorConfig.GetColorValue( ::svtools::FONTCOLOR ).nColor ) );
210
211 const StyleSettings& rSett = GetSettings().GetStyleSettings();
212 maHeaderBackColor = rSett.GetFaceColor();
213 maHeaderGridColor = rSett.GetDarkShadowColor();
214 maHeaderTextColor = rSett.GetButtonTextColor();
215 maSelectColor = rSett.GetActiveColor();
216
217 InvalidateGfx();
218 }
219
220 void ScCsvGrid::InitFonts()
221 {
222 maMonoFont = OutputDevice::GetDefaultFont( DEFAULTFONT_FIXED, LANGUAGE_ENGLISH_US, 0 );
223 maMonoFont.SetSize( Size( maMonoFont.GetSize().Width(), maHeaderFont.GetSize().Height() ) );
224
225 /* *** Set edit engine defaults ***
226 maMonoFont for Latin script, smaller default font for Asian and Complex script. */
227
228 // get default fonts
229 SvxFontItem aLatinItem( EE_CHAR_FONTINFO );
230 SvxFontItem aAsianItem( EE_CHAR_FONTINFO_CJK );
231 SvxFontItem aComplexItem( EE_CHAR_FONTINFO_CTL );
232 ::GetDefaultFonts( aLatinItem, aAsianItem, aComplexItem );
233
234 // create item set for defaults
235 SfxItemSet aDefSet( mpEditEngine->GetEmptyItemSet() );
236 EditEngine::SetFontInfoInItemSet( aDefSet, maMonoFont );
237 aDefSet.Put( aAsianItem );
238 aDefSet.Put( aComplexItem );
239
240 // set Asian/Complex font size to height of character in Latin font
241 ULONG nFontHt = static_cast< ULONG >( maMonoFont.GetSize().Height() );
242 aDefSet.Put( SvxFontHeightItem( nFontHt, 100, EE_CHAR_FONTHEIGHT_CJK ) );
243 aDefSet.Put( SvxFontHeightItem( nFontHt, 100, EE_CHAR_FONTHEIGHT_CTL ) );
244
245 // copy other items from default font
246 const SfxPoolItem& rWeightItem = aDefSet.Get( EE_CHAR_WEIGHT );
247 aDefSet.Put( rWeightItem, EE_CHAR_WEIGHT_CJK );
248 aDefSet.Put( rWeightItem, EE_CHAR_WEIGHT_CTL );
249 const SfxPoolItem& rItalicItem = aDefSet.Get( EE_CHAR_ITALIC );
250 aDefSet.Put( rItalicItem, EE_CHAR_ITALIC_CJK );
251 aDefSet.Put( rItalicItem, EE_CHAR_ITALIC_CTL );
252 const SfxPoolItem& rLangItem = aDefSet.Get( EE_CHAR_LANGUAGE );
253 aDefSet.Put( rLangItem, EE_CHAR_LANGUAGE_CJK );
254 aDefSet.Put( rLangItem, EE_CHAR_LANGUAGE_CTL );
255
256 mpEditEngine->SetDefaults( aDefSet );
257 InvalidateGfx();
258 }
259
260 void ScCsvGrid::InitSizeData()
261 {
262 maWinSize = GetSizePixel();
263 maBackgrDev.SetOutputSizePixel( maWinSize );
264 maGridDev.SetOutputSizePixel( maWinSize );
265 InvalidateGfx();
266 }
267
268
269 // split handling -------------------------------------------------------------
270
271 void ScCsvGrid::InsertSplit( sal_Int32 nPos )
272 {
273 if( ImplInsertSplit( nPos ) )
274 {
275 DisableRepaint();
276 Execute( CSVCMD_EXPORTCOLUMNTYPE );
277 Execute( CSVCMD_UPDATECELLTEXTS );
278 sal_uInt32 nColIx = GetColumnFromPos( nPos );
279 ImplDrawColumn( nColIx - 1 );
280 ImplDrawColumn( nColIx );
281 ValidateGfx(); // performance: do not redraw all columns
282 EnableRepaint();
283 }
284 }
285
286 void ScCsvGrid::RemoveSplit( sal_Int32 nPos )
287 {
288 if( ImplRemoveSplit( nPos ) )
289 {
290 DisableRepaint();
291 Execute( CSVCMD_EXPORTCOLUMNTYPE );
292 Execute( CSVCMD_UPDATECELLTEXTS );
293 ImplDrawColumn( GetColumnFromPos( nPos ) );
294 ValidateGfx(); // performance: do not redraw all columns
295 EnableRepaint();
296 }
297 }
298
299 void ScCsvGrid::MoveSplit( sal_Int32 nPos, sal_Int32 nNewPos )
300 {
301 sal_uInt32 nColIx = GetColumnFromPos( nPos );
302 if( nColIx != CSV_COLUMN_INVALID )
303 {
304 DisableRepaint();
305 if( (GetColumnPos( nColIx - 1 ) < nNewPos) && (nNewPos < GetColumnPos( nColIx + 1 )) )
306 {
307 // move a split in the range between 2 others -> keep selection state of both columns
308 maSplits.Remove( nPos );
309 maSplits.Insert( nNewPos );
310 Execute( CSVCMD_UPDATECELLTEXTS );
311 ImplDrawColumn( nColIx - 1 );
312 ImplDrawColumn( nColIx );
313 ValidateGfx(); // performance: do not redraw all columns
314 AccSendTableUpdateEvent( nColIx - 1, nColIx );
315 }
316 else
317 {
318 ImplRemoveSplit( nPos );
319 ImplInsertSplit( nNewPos );
320 Execute( CSVCMD_EXPORTCOLUMNTYPE );
321 Execute( CSVCMD_UPDATECELLTEXTS );
322 }
323 EnableRepaint();
324 }
325 }
326
327 void ScCsvGrid::RemoveAllSplits()
328 {
329 DisableRepaint();
330 ImplClearSplits();
331 Execute( CSVCMD_EXPORTCOLUMNTYPE );
332 Execute( CSVCMD_UPDATECELLTEXTS );
333 EnableRepaint();
334 }
335
336 void ScCsvGrid::SetSplits( const ScCsvSplits& rSplits )
337 {
338 DisableRepaint();
339 ImplClearSplits();
340 sal_uInt32 nCount = rSplits.Count();
341 for( sal_uInt32 nIx = 0; nIx < nCount; ++nIx )
342 maSplits.Insert( rSplits[ nIx ] );
343 maColStates.clear();
344 maColStates.resize( maSplits.Count() - 1 );
345 Execute( CSVCMD_EXPORTCOLUMNTYPE );
346 Execute( CSVCMD_UPDATECELLTEXTS );
347 EnableRepaint();
348 }
349
350 bool ScCsvGrid::ImplInsertSplit( sal_Int32 nPos )
351 {
352 sal_uInt32 nColIx = GetColumnFromPos( nPos );
353 bool bRet = (nColIx < GetColumnCount()) && maSplits.Insert( nPos );
354 if( bRet )
355 {
356 ScCsvColState aState( GetColumnType( nColIx ) );
357 aState.Select( IsSelected( nColIx ) && IsSelected( nColIx + 1 ) );
358 maColStates.insert( maColStates.begin() + nColIx + 1, aState );
359 AccSendInsertColumnEvent( nColIx + 1, nColIx + 1 );
360 AccSendTableUpdateEvent( nColIx, nColIx );
361 }
362 return bRet;
363 }
364
365 bool ScCsvGrid::ImplRemoveSplit( sal_Int32 nPos )
366 {
367 bool bRet = maSplits.Remove( nPos );
368 if( bRet )
369 {
370 sal_uInt32 nColIx = GetColumnFromPos( nPos );
371 bool bSel = IsSelected( nColIx ) || IsSelected( nColIx + 1 );
372 maColStates.erase( maColStates.begin() + nColIx + 1 );
373 maColStates[ nColIx ].Select( bSel );
374 AccSendRemoveColumnEvent( nColIx + 1, nColIx + 1 );
375 AccSendTableUpdateEvent( nColIx, nColIx );
376 }
377 return bRet;
378 }
379
380 void ScCsvGrid::ImplClearSplits()
381 {
382 sal_uInt32 nColumns = GetColumnCount();
383 maSplits.Clear();
384 maSplits.Insert( 0 );
385 maSplits.Insert( GetPosCount() );
386 maColStates.resize( 1 );
387 InvalidateGfx();
388 AccSendRemoveColumnEvent( 1, nColumns - 1 );
389 }
390
391 // columns/column types -------------------------------------------------------
392
393 sal_uInt32 ScCsvGrid::GetFirstVisColumn() const
394 {
395 return GetColumnFromPos( GetFirstVisPos() );
396 }
397
398 sal_uInt32 ScCsvGrid::GetLastVisColumn() const
399 {
400 return GetColumnFromPos( Min( GetLastVisPos(), GetPosCount() ) - 1 );
401 }
402
403 bool ScCsvGrid::IsValidColumn( sal_uInt32 nColIndex ) const
404 {
405 return nColIndex < GetColumnCount();
406 }
407
408 bool ScCsvGrid::IsVisibleColumn( sal_uInt32 nColIndex ) const
409 {
410 return IsValidColumn( nColIndex ) &&
411 (GetColumnPos( nColIndex ) < GetLastVisPos()) &&
412 (GetFirstVisPos() < GetColumnPos( nColIndex + 1 ));
413 }
414
415 sal_Int32 ScCsvGrid::GetColumnX( sal_uInt32 nColIndex ) const
416 {
417 return GetX( GetColumnPos( nColIndex ) );
418 }
419
420 sal_uInt32 ScCsvGrid::GetColumnFromX( sal_Int32 nX ) const
421 {
422 sal_Int32 nPos = (nX - GetFirstX()) / GetCharWidth() + GetFirstVisPos();
423 return ((GetFirstVisPos() <= nPos) && (nPos <= GetLastVisPos())) ?
424 GetColumnFromPos( nPos ) : CSV_COLUMN_INVALID;
425 }
426
427 sal_uInt32 ScCsvGrid::GetColumnFromPos( sal_Int32 nPos ) const
428 {
429 return maSplits.UpperBound( nPos );
430 }
431
432 sal_Int32 ScCsvGrid::GetColumnWidth( sal_uInt32 nColIndex ) const
433 {
434 return IsValidColumn( nColIndex ) ? (GetColumnPos( nColIndex + 1 ) - GetColumnPos( nColIndex )) : 0;
435 }
436
437 void ScCsvGrid::SetColumnStates( const ScCsvColStateVec& rStates )
438 {
439 maColStates = rStates;
440 maColStates.resize( maSplits.Count() - 1 );
441 Execute( CSVCMD_EXPORTCOLUMNTYPE );
442 AccSendTableUpdateEvent( 0, GetColumnCount(), false );
443 AccSendSelectionEvent();
444 }
445
446 sal_Int32 ScCsvGrid::GetColumnType( sal_uInt32 nColIndex ) const
447 {
448 return IsValidColumn( nColIndex ) ? maColStates[ nColIndex ].mnType : CSV_TYPE_NOSELECTION;
449 }
450
451 void ScCsvGrid::SetColumnType( sal_uInt32 nColIndex, sal_Int32 nColType )
452 {
453 if( IsValidColumn( nColIndex ) )
454 {
455 maColStates[ nColIndex ].mnType = nColType;
456 AccSendTableUpdateEvent( nColIndex, nColIndex, false );
457 }
458 }
459
460 sal_Int32 ScCsvGrid::GetSelColumnType() const
461 {
462 sal_uInt32 nColIx = GetFirstSelected();
463 if( nColIx == CSV_COLUMN_INVALID )
464 return CSV_TYPE_NOSELECTION;
465
466 sal_Int32 nType = GetColumnType( nColIx );
467 while( (nColIx != CSV_COLUMN_INVALID) && (nType != CSV_TYPE_MULTI) )
468 {
469 if( nType != GetColumnType( nColIx ) )
470 nType = CSV_TYPE_MULTI;
471 nColIx = GetNextSelected( nColIx );
472 }
473 return nType;
474 }
475
476 void ScCsvGrid::SetSelColumnType( sal_Int32 nType )
477 {
478 if( (nType != CSV_TYPE_MULTI) && (nType != CSV_TYPE_NOSELECTION) )
479 {
480 for( sal_uInt32 nColIx = GetFirstSelected(); nColIx != CSV_COLUMN_INVALID; nColIx = GetNextSelected( nColIx ) )
481 SetColumnType( nColIx, nType );
482 Repaint( true );
483 Execute( CSVCMD_EXPORTCOLUMNTYPE );
484 }
485 }
486
487 void ScCsvGrid::SetTypeNames( const StringVec& rTypeNames )
488 {
489 DBG_ASSERT( !rTypeNames.empty(), "ScCsvGrid::SetTypeNames - vector is empty" );
490 maTypeNames = rTypeNames;
491 Repaint( true );
492
493 maPopup.Clear();
494 sal_uInt32 nCount = maTypeNames.size();
495 sal_uInt32 nIx;
496 sal_uInt16 nItemId;
497 for( nIx = 0, nItemId = 1; nIx < nCount; ++nIx, ++nItemId )
498 maPopup.InsertItem( nItemId, maTypeNames[ nIx ] );
499
500 ::std::for_each( maColStates.begin(), maColStates.end(), Func_SetType( CSV_TYPE_DEFAULT ) );
501 }
502
503 const String& ScCsvGrid::GetColumnTypeName( sal_uInt32 nColIndex ) const
504 {
505 sal_uInt32 nTypeIx = static_cast< sal_uInt32 >( GetColumnType( nColIndex ) );
506 return (nTypeIx < maTypeNames.size()) ? maTypeNames[ nTypeIx ] : EMPTY_STRING;
507 }
508
509 sal_uInt8 lcl_GetExtColumnType( sal_Int32 nIntType )
510 {
511 static sal_uInt8 pExtTypes[] =
512 { SC_COL_STANDARD, SC_COL_TEXT, SC_COL_DMY, SC_COL_MDY, SC_COL_YMD, SC_COL_ENGLISH, SC_COL_SKIP };
513 static sal_Int32 nExtTypeCount = sizeof( pExtTypes ) / sizeof( *pExtTypes );
514 return pExtTypes[ ((0 <= nIntType) && (nIntType < nExtTypeCount)) ? nIntType : 0 ];
515 }
516
517 void ScCsvGrid::FillColumnDataSep( ScAsciiOptions& rOptions ) const
518 {
519 sal_uInt32 nCount = GetColumnCount();
520 ScCsvExpDataVec aDataVec;
521
522 for( sal_uInt32 nColIx = 0; nColIx < nCount; ++nColIx )
523 {
524 if( GetColumnType( nColIx ) != CSV_TYPE_DEFAULT )
525 // 1-based column index
526 aDataVec.push_back( ScCsvExpData(
527 static_cast< xub_StrLen >( nColIx + 1 ),
528 lcl_GetExtColumnType( GetColumnType( nColIx ) ) ) );
529 }
530 rOptions.SetColumnInfo( aDataVec );
531 }
532
533 void ScCsvGrid::FillColumnDataFix( ScAsciiOptions& rOptions ) const
534 {
535 sal_uInt32 nCount = Min( GetColumnCount(), static_cast<sal_uInt32>(MAXCOLCOUNT) );
536 ScCsvExpDataVec aDataVec( nCount + 1 );
537
538 for( sal_uInt32 nColIx = 0; nColIx < nCount; ++nColIx )
539 {
540 ScCsvExpData& rData = aDataVec[ nColIx ];
541 rData.mnIndex = static_cast< xub_StrLen >(
542 Min( static_cast< sal_Int32 >( STRING_MAXLEN ), GetColumnPos( nColIx ) ) );
543 rData.mnType = lcl_GetExtColumnType( GetColumnType( nColIx ) );
544 }
545 aDataVec[ nCount ].mnIndex = STRING_MAXLEN;
546 aDataVec[ nCount ].mnType = SC_COL_SKIP;
547 rOptions.SetColumnInfo( aDataVec );
548 }
549
550 void ScCsvGrid::ScrollVertRel( ScMoveMode eDir )
551 {
552 sal_Int32 nLine = GetFirstVisLine();
553 switch( eDir )
554 {
555 case MOVE_PREV: --nLine; break;
556 case MOVE_NEXT: ++nLine; break;
557 case MOVE_FIRST: nLine = 0; break;
558 case MOVE_LAST: nLine = GetMaxLineOffset(); break;
559 case MOVE_PREVPAGE: nLine -= GetVisLineCount() - 2; break;
560 case MOVE_NEXTPAGE: nLine += GetVisLineCount() - 2; break;
561 default:
562 {
563 // added to avoid warnings
564 }
565 }
566 Execute( CSVCMD_SETLINEOFFSET, nLine );
567 }
568
569 void ScCsvGrid::ExecutePopup( const Point& rPos )
570 {
571 sal_uInt16 nItemId = maPopup.Execute( this, rPos );
572 if( nItemId ) // 0 = cancelled
573 Execute( CSVCMD_SETCOLUMNTYPE, maPopup.GetItemPos( nItemId ) );
574 }
575
576
577 // selection handling ---------------------------------------------------------
578
579 bool ScCsvGrid::IsSelected( sal_uInt32 nColIndex ) const
580 {
581 return IsValidColumn( nColIndex ) && maColStates[ nColIndex ].IsSelected();
582 }
583
584 sal_uInt32 ScCsvGrid::GetFirstSelected() const
585 {
586 return IsSelected( 0 ) ? 0 : GetNextSelected( 0 );
587 }
588
589 sal_uInt32 ScCsvGrid::GetNextSelected( sal_uInt32 nFromIndex ) const
590 {
591 sal_uInt32 nColCount = GetColumnCount();
592 for( sal_uInt32 nColIx = nFromIndex + 1; nColIx < nColCount; ++nColIx )
593 if( IsSelected( nColIx ) )
594 return nColIx;
595 return CSV_COLUMN_INVALID;
596 }
597
598 void ScCsvGrid::Select( sal_uInt32 nColIndex, bool bSelect )
599 {
600 if( IsValidColumn( nColIndex ) )
601 {
602 maColStates[ nColIndex ].Select( bSelect );
603 ImplDrawColumnSelection( nColIndex );
604 Repaint();
605 Execute( CSVCMD_EXPORTCOLUMNTYPE );
606 if( bSelect )
607 mnRecentSelCol = nColIndex;
608 AccSendSelectionEvent();
609 }
610 }
611
612 void ScCsvGrid::ToggleSelect( sal_uInt32 nColIndex )
613 {
614 Select( nColIndex, !IsSelected( nColIndex ) );
615 }
616
617 void ScCsvGrid::SelectRange( sal_uInt32 nColIndex1, sal_uInt32 nColIndex2, bool bSelect )
618 {
619 if( nColIndex1 == CSV_COLUMN_INVALID )
620 Select( nColIndex2 );
621 else if( nColIndex2 == CSV_COLUMN_INVALID )
622 Select( nColIndex1 );
623 else if( nColIndex1 > nColIndex2 )
624 {
625 SelectRange( nColIndex2, nColIndex1, bSelect );
626 if( bSelect )
627 mnRecentSelCol = nColIndex1;
628 }
629 else if( IsValidColumn( nColIndex1 ) && IsValidColumn( nColIndex2 ) )
630 {
631 for( sal_uInt32 nColIx = nColIndex1; nColIx <= nColIndex2; ++nColIx )
632 {
633 maColStates[ nColIx ].Select( bSelect );
634 ImplDrawColumnSelection( nColIx );
635 }
636 Repaint();
637 Execute( CSVCMD_EXPORTCOLUMNTYPE );
638 if( bSelect )
639 mnRecentSelCol = nColIndex1;
640 AccSendSelectionEvent();
641 }
642 }
643
644 void ScCsvGrid::SelectAll( bool bSelect )
645 {
646 SelectRange( 0, GetColumnCount() - 1, bSelect );
647 }
648
649 void ScCsvGrid::MoveCursor( sal_uInt32 nColIndex )
650 {
651 DisableRepaint();
652 if( IsValidColumn( nColIndex ) )
653 {
654 sal_Int32 nPosBeg = GetColumnPos( nColIndex );
655 sal_Int32 nPosEnd = GetColumnPos( nColIndex + 1 );
656 sal_Int32 nMinPos = Max( nPosBeg - CSV_SCROLL_DIST, sal_Int32( 0 ) );
657 sal_Int32 nMaxPos = Min( nPosEnd - GetVisPosCount() + CSV_SCROLL_DIST + sal_Int32( 1 ), nMinPos );
658 if( nPosBeg - CSV_SCROLL_DIST + 1 <= GetFirstVisPos() )
659 Execute( CSVCMD_SETPOSOFFSET, nMinPos );
660 else if( nPosEnd + CSV_SCROLL_DIST >= GetLastVisPos() )
661 Execute( CSVCMD_SETPOSOFFSET, nMaxPos );
662 }
663 Execute( CSVCMD_MOVEGRIDCURSOR, GetColumnPos( nColIndex ) );
664 EnableRepaint();
665 }
666
667 void ScCsvGrid::MoveCursorRel( ScMoveMode eDir )
668 {
669 if( GetFocusColumn() != CSV_COLUMN_INVALID )
670 {
671 switch( eDir )
672 {
673 case MOVE_FIRST:
674 MoveCursor( 0 );
675 break;
676 case MOVE_LAST:
677 MoveCursor( GetColumnCount() - 1 );
678 break;
679 case MOVE_PREV:
680 if( GetFocusColumn() > 0 )
681 MoveCursor( GetFocusColumn() - 1 );
682 break;
683 case MOVE_NEXT:
684 if( GetFocusColumn() < GetColumnCount() - 1 )
685 MoveCursor( GetFocusColumn() + 1 );
686 break;
687 default:
688 {
689 // added to avoid warnings
690 }
691 }
692 }
693 }
694
695 void ScCsvGrid::ImplClearSelection()
696 {
697 ::std::for_each( maColStates.begin(), maColStates.end(), Func_Select( false ) );
698 ImplDrawGridDev();
699 }
700
701 void ScCsvGrid::DoSelectAction( sal_uInt32 nColIndex, sal_uInt16 nModifier )
702 {
703 if( !(nModifier & KEY_MOD1) )
704 ImplClearSelection();
705 if( nModifier & KEY_SHIFT ) // SHIFT always expands
706 SelectRange( mnRecentSelCol, nColIndex );
707 else if( !(nModifier & KEY_MOD1) ) // no SHIFT/CTRL always selects 1 column
708 Select( nColIndex );
709 else if( IsTracking() ) // CTRL in tracking does not toggle
710 Select( nColIndex, mbMTSelecting );
711 else // CTRL only toggles
712 ToggleSelect( nColIndex );
713 Execute( CSVCMD_MOVEGRIDCURSOR, GetColumnPos( nColIndex ) );
714 }
715
716
717 // cell contents --------------------------------------------------------------
718
719 void ScCsvGrid::ImplSetTextLineSep(
720 sal_Int32 nLine, const String& rTextLine,
721 const String& rSepChars, sal_Unicode cTextSep, bool bMergeSep )
722 {
723 if( nLine < GetFirstVisLine() ) return;
724
725 sal_uInt32 nLineIx = nLine - GetFirstVisLine();
726 while( maTexts.size() <= nLineIx )
727 maTexts.push_back( StringVec() );
728 StringVec& rStrVec = maTexts[ nLineIx ];
729 rStrVec.clear();
730
731 // scan for separators
732 String aCellText;
733 const sal_Unicode* pSepChars = rSepChars.GetBuffer();
734 const sal_Unicode* pChar = rTextLine.GetBuffer();
735 sal_uInt32 nColIx = 0;
736
737 while( *pChar && (nColIx < sal::static_int_cast<sal_uInt32>(CSV_MAXCOLCOUNT)) )
738 {
739 // scan for next cell text
740 bool bIsQuoted = false;
741 pChar = ScImportExport::ScanNextFieldFromString( pChar, aCellText, cTextSep, pSepChars, bMergeSep, bIsQuoted );
742
743 // update column width
744 sal_Int32 nWidth = Max( CSV_MINCOLWIDTH, aCellText.Len() + sal_Int32( 1 ) );
745 if( IsValidColumn( nColIx ) )
746 {
747 // expand existing column
748 sal_Int32 nDiff = nWidth - GetColumnWidth( nColIx );
749 if( nDiff > 0 )
750 {
751 Execute( CSVCMD_SETPOSCOUNT, GetPosCount() + nDiff );
752 for( sal_uInt32 nSplitIx = GetColumnCount() - 1; nSplitIx > nColIx; --nSplitIx )
753 {
754 sal_Int32 nPos = maSplits[ nSplitIx ];
755 maSplits.Remove( nPos );
756 maSplits.Insert( nPos + nDiff );
757 }
758 }
759 }
760 else
761 {
762 // append new column
763 sal_Int32 nLastPos = GetPosCount();
764 Execute( CSVCMD_SETPOSCOUNT, nLastPos + nWidth );
765 ImplInsertSplit( nLastPos );
766 }
767
768 if( aCellText.Len() <= CSV_MAXSTRLEN )
769 rStrVec.push_back( aCellText );
770 else
771 rStrVec.push_back( aCellText.Copy( 0, CSV_MAXSTRLEN ) );
772 ++nColIx;
773 }
774 InvalidateGfx();
775 }
776
777 void ScCsvGrid::ImplSetTextLineFix( sal_Int32 nLine, const String& rTextLine )
778 {
779 if( nLine < GetFirstVisLine() ) return;
780
781 sal_Int32 nChars = rTextLine.Len();
782 if( nChars > GetPosCount() )
783 Execute( CSVCMD_SETPOSCOUNT, nChars );
784
785 sal_uInt32 nLineIx = nLine - GetFirstVisLine();
786 while( maTexts.size() <= nLineIx )
787 maTexts.push_back( StringVec() );
788
789 StringVec& rStrVec = maTexts[ nLineIx ];
790 rStrVec.clear();
791 sal_uInt32 nColCount = GetColumnCount();
792 xub_StrLen nStrLen = rTextLine.Len();
793 xub_StrLen nStrIx = 0;
794 for( sal_uInt32 nColIx = 0; (nColIx < nColCount) && (nStrIx < nStrLen); ++nColIx )
795 {
796 xub_StrLen nColWidth = static_cast< xub_StrLen >( GetColumnWidth( nColIx ) );
797 rStrVec.push_back( rTextLine.Copy( nStrIx, Max( nColWidth, CSV_MAXSTRLEN ) ) );
798 nStrIx = sal::static_int_cast<xub_StrLen>( nStrIx + nColWidth );
799 }
800 InvalidateGfx();
801 }
802
803 const String& ScCsvGrid::GetCellText( sal_uInt32 nColIndex, sal_Int32 nLine ) const
804 {
805 if( nLine < GetFirstVisLine() ) return EMPTY_STRING;
806
807 sal_uInt32 nLineIx = nLine - GetFirstVisLine();
808 if( nLineIx >= maTexts.size() ) return EMPTY_STRING;
809
810 const StringVec& rStrVec = maTexts[ nLineIx ];
811 if( nColIndex >= rStrVec.size() ) return EMPTY_STRING;
812
813 return rStrVec[ nColIndex ];
814 }
815
816
817 // event handling -------------------------------------------------------------
818
819 void ScCsvGrid::Resize()
820 {
821 ScCsvControl::Resize();
822 InitSizeData();
823 Execute( CSVCMD_UPDATECELLTEXTS );
824 }
825
826 void ScCsvGrid::GetFocus()
827 {
828 ScCsvControl::GetFocus();
829 Execute( CSVCMD_MOVEGRIDCURSOR, GetNoScrollCol( GetGridCursorPos() ) );
830 Repaint();
831 }
832
833 void ScCsvGrid::LoseFocus()
834 {
835 ScCsvControl::LoseFocus();
836 Repaint();
837 }
838
839 void ScCsvGrid::MouseButtonDown( const MouseEvent& rMEvt )
840 {
841 DisableRepaint();
842 if( !HasFocus() )
843 GrabFocus();
844
845 Point aPos( rMEvt.GetPosPixel() );
846 sal_uInt32 nColIx = GetColumnFromX( aPos.X() );
847
848 if( rMEvt.IsLeft() )
849 {
850 if( (GetFirstX() > aPos.X()) || (aPos.X() > GetLastX()) ) // in header column
851 {
852 if( aPos.Y() <= GetHdrHeight() )
853 SelectAll();
854 }
855 else if( IsValidColumn( nColIx ) )
856 {
857 DoSelectAction( nColIx, rMEvt.GetModifier() );
858 mnMTCurrCol = nColIx;
859 mbMTSelecting = IsSelected( nColIx );
860 StartTracking( STARTTRACK_BUTTONREPEAT );
861 }
862 }
863 EnableRepaint();
864 }
865
866 void ScCsvGrid::Tracking( const TrackingEvent& rTEvt )
867 {
868 if( rTEvt.IsTrackingEnded() || rTEvt.IsTrackingRepeat() )
869 {
870 DisableRepaint();
871 const MouseEvent& rMEvt = rTEvt.GetMouseEvent();
872
873 sal_Int32 nPos = (rMEvt.GetPosPixel().X() - GetFirstX()) / GetCharWidth() + GetFirstVisPos();
874 // on mouse tracking: keep position valid
875 nPos = Max( Min( nPos, GetPosCount() - sal_Int32( 1 ) ), sal_Int32( 0 ) );
876 Execute( CSVCMD_MAKEPOSVISIBLE, nPos );
877
878 sal_uInt32 nColIx = GetColumnFromPos( nPos );
879 if( mnMTCurrCol != nColIx )
880 {
881 DoSelectAction( nColIx, rMEvt.GetModifier() );
882 mnMTCurrCol = nColIx;
883 }
884 EnableRepaint();
885 }
886 }
887
888 void ScCsvGrid::KeyInput( const KeyEvent& rKEvt )
889 {
890 const KeyCode& rKCode = rKEvt.GetKeyCode();
891 sal_uInt16 nCode = rKCode.GetCode();
892 bool bShift = rKCode.IsShift() == TRUE;
893 bool bMod1 = rKCode.IsMod1() == TRUE;
894
895 if( !rKCode.IsMod2() )
896 {
897 ScMoveMode eHDir = GetHorzDirection( nCode, !bMod1 );
898 ScMoveMode eVDir = GetVertDirection( nCode, bMod1 );
899
900 if( eHDir != MOVE_NONE )
901 {
902 DisableRepaint();
903 MoveCursorRel( eHDir );
904 if( !bMod1 )
905 ImplClearSelection();
906 if( bShift )
907 SelectRange( mnRecentSelCol, GetFocusColumn() );
908 else if( !bMod1 )
909 Select( GetFocusColumn() );
910 EnableRepaint();
911 }
912 else if( eVDir != MOVE_NONE )
913 ScrollVertRel( eVDir );
914 else if( nCode == KEY_SPACE )
915 {
916 if( !bMod1 )
917 ImplClearSelection();
918 if( bShift )
919 SelectRange( mnRecentSelCol, GetFocusColumn() );
920 else if( bMod1 )
921 ToggleSelect( GetFocusColumn() );
922 else
923 Select( GetFocusColumn() );
924 }
925 else if( !bShift && bMod1 )
926 {
927 if( nCode == KEY_A )
928 SelectAll();
929 else if( (KEY_1 <= nCode) && (nCode <= KEY_9) )
930 {
931 sal_uInt32 nType = nCode - KEY_1;
932 if( nType < maTypeNames.size() )
933 Execute( CSVCMD_SETCOLUMNTYPE, nType );
934 }
935 }
936 }
937
938 if( rKCode.GetGroup() != KEYGROUP_CURSOR )
939 ScCsvControl::KeyInput( rKEvt );
940 }
941
942 void ScCsvGrid::Command( const CommandEvent& rCEvt )
943 {
944 switch( rCEvt.GetCommand() )
945 {
946 case COMMAND_CONTEXTMENU:
947 {
948 if( rCEvt.IsMouseEvent() )
949 {
950 Point aPos( rCEvt.GetMousePosPixel() );
951 sal_uInt32 nColIx = GetColumnFromX( aPos.X() );
952 if( IsValidColumn( nColIx ) && (GetFirstX() <= aPos.X()) && (aPos.X() <= GetLastX()) )
953 {
954 if( !IsSelected( nColIx ) )
955 DoSelectAction( nColIx, 0 ); // focus & select
956 ExecutePopup( aPos );
957 }
958 }
959 else
960 {
961 sal_uInt32 nColIx = GetFocusColumn();
962 if( !IsSelected( nColIx ) )
963 Select( nColIx );
964 sal_Int32 nX1 = Max( GetColumnX( nColIx ), GetFirstX() );
965 sal_Int32 nX2 = Min( GetColumnX( nColIx + 1 ), GetWidth() );
966 ExecutePopup( Point( (nX1 + nX2) / 2, GetHeight() / 2 ) );
967 }
968 }
969 break;
970 case COMMAND_WHEEL:
971 {
972 Point aPoint;
973 Rectangle aRect( aPoint, maWinSize );
974 if( aRect.IsInside( rCEvt.GetMousePosPixel() ) )
975 {
976 const CommandWheelData* pData = rCEvt.GetWheelData();
977 if( pData && (pData->GetMode() == COMMAND_WHEEL_SCROLL) && !pData->IsHorz() )
978 Execute( CSVCMD_SETLINEOFFSET, GetFirstVisLine() - pData->GetNotchDelta() );
979 }
980 }
981 break;
982 default:
983 ScCsvControl::Command( rCEvt );
984 }
985 }
986
987 void ScCsvGrid::DataChanged( const DataChangedEvent& rDCEvt )
988 {
989 if( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_STYLE) )
990 {
991 InitColors();
992 InitFonts();
993 UpdateLayoutData();
994 Execute( CSVCMD_UPDATECELLTEXTS );
995 }
996 ScCsvControl::DataChanged( rDCEvt );
997 }
998
999 void ScCsvGrid::Notify( SfxBroadcaster&, const SfxHint& rHint )
1000 {
1001 if( rHint.ISA( SfxSimpleHint ) &&
1002 (static_cast< const SfxSimpleHint& >( rHint ).GetId() == SFX_HINT_COLORS_CHANGED) )
1003 {
1004 InitColors();
1005 Repaint();
1006 }
1007 }
1008
1009
1010 // painting -------------------------------------------------------------------
1011
1012 void ScCsvGrid::Paint( const Rectangle& )
1013 {
1014 Repaint();
1015 }
1016
1017 void ScCsvGrid::ImplRedraw()
1018 {
1019 if( IsVisible() )
1020 {
1021 if( !IsValidGfx() )
1022 {
1023 ValidateGfx();
1024 ImplDrawBackgrDev();
1025 ImplDrawGridDev();
1026 }
1027 DrawOutDev( Point(), maWinSize, Point(), maWinSize, maGridDev );
1028 ImplDrawTrackingRect( GetFocusColumn() );
1029 }
1030 }
1031
1032 EditEngine* ScCsvGrid::GetEditEngine()
1033 {
1034 return mpEditEngine.get();
1035 }
1036
1037 void ScCsvGrid::ImplSetColumnClipRegion( OutputDevice& rOutDev, sal_uInt32 nColIndex )
1038 {
1039 rOutDev.SetClipRegion( Region( Rectangle(
1040 Max( GetColumnX( nColIndex ), GetFirstX() ) + 1, 0,
1041 Min( GetColumnX( nColIndex + 1 ), GetLastX() ), GetHeight() - 1 ) ) );
1042 }
1043
1044 void ScCsvGrid::ImplDrawColumnHeader( OutputDevice& rOutDev, sal_uInt32 nColIndex, Color aFillColor )
1045 {
1046 sal_Int32 nX1 = GetColumnX( nColIndex ) + 1;
1047 sal_Int32 nX2 = GetColumnX( nColIndex + 1 );
1048 sal_Int32 nHdrHt = GetHdrHeight();
1049
1050 rOutDev.SetLineColor();
1051 rOutDev.SetFillColor( aFillColor );
1052 rOutDev.DrawRect( Rectangle( nX1, 0, nX2, nHdrHt ) );
1053
1054 rOutDev.SetFont( maHeaderFont );
1055 rOutDev.SetTextColor( maHeaderTextColor );
1056 rOutDev.SetTextFillColor();
1057 rOutDev.DrawText( Point( nX1 + 1, 0 ), GetColumnTypeName( nColIndex ) );
1058
1059 rOutDev.SetLineColor( maHeaderGridColor );
1060 rOutDev.DrawLine( Point( nX1, nHdrHt ), Point( nX2, nHdrHt ) );
1061 rOutDev.DrawLine( Point( nX2, 0 ), Point( nX2, nHdrHt ) );
1062 }
1063
1064 void ScCsvGrid::ImplDrawCellText( const Point& rPos, const String& rText )
1065 {
1066 String aPlainText( rText );
1067 aPlainText.SearchAndReplaceAll( '\t', ' ' );
1068 aPlainText.SearchAndReplaceAll( '\n', ' ' );
1069 mpEditEngine->SetPaperSize( maEdEngSize );
1070
1071 /* #i60296# If string contains mixed script types, the space character
1072 U+0020 may be drawn with a wrong width (from non-fixed-width Asian or
1073 Complex font). Now we draw every non-space portion separately. */
1074 xub_StrLen nTokenCount = aPlainText.GetTokenCount( ' ' );
1075 xub_StrLen nCharIx = 0;
1076 for( xub_StrLen nToken = 0; nToken < nTokenCount; ++nToken )
1077 {
1078 xub_StrLen nBeginIx = nCharIx;
1079 String aToken = aPlainText.GetToken( 0, ' ', nCharIx );
1080 if( aToken.Len() > 0 )
1081 {
1082 sal_Int32 nX = rPos.X() + GetCharWidth() * nBeginIx;
1083 mpEditEngine->SetText( aToken );
1084 mpEditEngine->Draw( &maBackgrDev, Point( nX, rPos.Y() ) );
1085 }
1086 }
1087
1088 nCharIx = 0;
1089 while( (nCharIx = rText.Search( '\t', nCharIx )) != STRING_NOTFOUND )
1090 {
1091 sal_Int32 nX1 = rPos.X() + GetCharWidth() * nCharIx;
1092 sal_Int32 nX2 = nX1 + GetCharWidth() - 2;
1093 sal_Int32 nY = rPos.Y() + GetLineHeight() / 2;
1094 Color aColor( maTextColor );
1095 maBackgrDev.SetLineColor( aColor );
1096 maBackgrDev.DrawLine( Point( nX1, nY ), Point( nX2, nY ) );
1097 maBackgrDev.DrawLine( Point( nX2 - 2, nY - 2 ), Point( nX2, nY ) );
1098 maBackgrDev.DrawLine( Point( nX2 - 2, nY + 2 ), Point( nX2, nY ) );
1099 ++nCharIx;
1100 }
1101 nCharIx = 0;
1102 while( (nCharIx = rText.Search( '\n', nCharIx )) != STRING_NOTFOUND )
1103 {
1104 sal_Int32 nX1 = rPos.X() + GetCharWidth() * nCharIx;
1105 sal_Int32 nX2 = nX1 + GetCharWidth() - 2;
1106 sal_Int32 nY = rPos.Y() + GetLineHeight() / 2;
1107 Color aColor( maTextColor );
1108 maBackgrDev.SetLineColor( aColor );
1109 maBackgrDev.DrawLine( Point( nX1, nY ), Point( nX2, nY ) );
1110 maBackgrDev.DrawLine( Point( nX1 + 2, nY - 2 ), Point( nX1, nY ) );
1111 maBackgrDev.DrawLine( Point( nX1 + 2, nY + 2 ), Point( nX1, nY ) );
1112 maBackgrDev.DrawLine( Point( nX2, nY - 2 ), Point( nX2, nY ) );
1113 ++nCharIx;
1114 }
1115 }
1116
1117 void ScCsvGrid::ImplDrawFirstLineSep( bool bSet )
1118 {
1119 if( IsVisibleLine( mnFirstImpLine ) && (mnFirstImpLine != GetFirstVisLine() ) )
1120 {
1121 sal_Int32 nY = GetY( mnFirstImpLine );
1122 sal_Int32 nX = Min( GetColumnX( GetLastVisColumn() + 1 ), GetLastX() );
1123 maBackgrDev.SetLineColor( bSet ? maGridPBColor : maGridColor );
1124 maBackgrDev.DrawLine( Point( GetFirstX() + 1, nY ), Point( nX, nY ) );
1125 }
1126 }
1127
1128 void ScCsvGrid::ImplDrawColumnBackgr( sal_uInt32 nColIndex )
1129 {
1130 if( !IsVisibleColumn( nColIndex ) )
1131 return;
1132
1133 ImplSetColumnClipRegion( maBackgrDev, nColIndex );
1134
1135 // grid
1136 maBackgrDev.SetLineColor();
1137 maBackgrDev.SetFillColor( maBackColor );
1138 sal_Int32 nX1 = GetColumnX( nColIndex ) + 1;
1139 sal_Int32 nX2 = GetColumnX( nColIndex + 1 );
1140 sal_Int32 nY2 = GetY( GetLastVisLine() + 1 );
1141 sal_Int32 nHdrHt = GetHdrHeight();
1142 Rectangle aRect( nX1, nHdrHt, nX2, nY2 );
1143 maBackgrDev.DrawRect( aRect );
1144 maBackgrDev.SetLineColor( maGridColor );
1145 maBackgrDev.DrawGrid( aRect, Size( 1, GetLineHeight() ), GRID_HORZLINES );
1146 maBackgrDev.DrawLine( Point( nX2, nHdrHt ), Point( nX2, nY2 ) );
1147 ImplDrawFirstLineSep( true );
1148
1149 // cell texts
1150 mpEditEngine->SetDefaultItem( SvxColorItem( maTextColor, EE_CHAR_COLOR ) );
1151 size_t nLineCount = ::std::min( static_cast< size_t >( GetLastVisLine() - GetFirstVisLine() + 1 ), maTexts.size() );
1152 // #i67432# cut string to avoid edit engine performance problems with very large strings
1153 sal_Int32 nFirstVisPos = ::std::max( GetColumnPos( nColIndex ), GetFirstVisPos() );
1154 sal_Int32 nLastVisPos = ::std::min( GetColumnPos( nColIndex + 1 ), GetLastVisPos() );
1155 xub_StrLen nStrPos = static_cast< xub_StrLen >( nFirstVisPos - GetColumnPos( nColIndex ) );
1156 xub_StrLen nStrLen = static_cast< xub_StrLen >( nLastVisPos - nFirstVisPos + 1 );
1157 sal_Int32 nStrX = GetX( nFirstVisPos );
1158 for( size_t nLine = 0; nLine < nLineCount; ++nLine )
1159 {
1160 StringVec& rStrVec = maTexts[ nLine ];
1161 if( (nColIndex < rStrVec.size()) && (rStrVec[ nColIndex ].Len() > nStrPos) )
1162 {
1163 String aText( rStrVec[ nColIndex ], nStrPos, nStrLen );
1164 ImplDrawCellText( Point( nStrX, GetY( GetFirstVisLine() + nLine ) ), aText );
1165 }
1166 }
1167
1168 // header
1169 ImplDrawColumnHeader( maBackgrDev, nColIndex, maHeaderBackColor );
1170
1171 maBackgrDev.SetClipRegion();
1172 }
1173
1174 void ScCsvGrid::ImplDrawRowHeaders()
1175 {
1176 maBackgrDev.SetLineColor();
1177 maBackgrDev.SetFillColor( maAppBackColor );
1178 Point aPoint( GetHdrX(), 0 );
1179 Rectangle aRect( aPoint, Size( GetHdrWidth() + 1, GetHeight() ) );
1180 maBackgrDev.DrawRect( aRect );
1181
1182 maBackgrDev.SetFillColor( maHeaderBackColor );
1183 aRect.Bottom() = GetY( GetLastVisLine() + 1 );
1184 maBackgrDev.DrawRect( aRect );
1185
1186 // line numbers
1187 maBackgrDev.SetFont( maHeaderFont );
1188 maBackgrDev.SetTextColor( maHeaderTextColor );
1189 maBackgrDev.SetTextFillColor();
1190 sal_Int32 nLastLine = GetLastVisLine();
1191 for( sal_Int32 nLine = GetFirstVisLine(); nLine <= nLastLine; ++nLine )
1192 {
1193 String aText( String::CreateFromInt32( nLine + 1 ) );
1194 sal_Int32 nX = GetHdrX() + (GetHdrWidth() - maBackgrDev.GetTextWidth( aText )) / 2;
1195 maBackgrDev.DrawText( Point( nX, GetY( nLine ) ), aText );
1196 }
1197
1198 // grid
1199 maBackgrDev.SetLineColor( maHeaderGridColor );
1200 if( IsRTL() )
1201 {
1202 maBackgrDev.DrawLine( Point( 0, 0 ), Point( 0, GetHeight() - 1 ) );
1203 maBackgrDev.DrawLine( aRect.TopLeft(), aRect.BottomLeft() );
1204 }
1205 else
1206 maBackgrDev.DrawLine( aRect.TopRight(), aRect.BottomRight() );
1207 aRect.Top() = GetHdrHeight();
1208 maBackgrDev.DrawGrid( aRect, Size( 1, GetLineHeight() ), GRID_HORZLINES );
1209 }
1210
1211 void ScCsvGrid::ImplDrawBackgrDev()
1212 {
1213 maBackgrDev.SetLineColor();
1214 maBackgrDev.SetFillColor( maAppBackColor );
1215 maBackgrDev.DrawRect( Rectangle(
1216 Point( GetFirstX() + 1, 0 ), Size( GetWidth() - GetHdrWidth(), GetHeight() ) ) );
1217
1218 sal_uInt32 nLastCol = GetLastVisColumn();
1219 for( sal_uInt32 nColIx = GetFirstVisColumn(); nColIx <= nLastCol; ++nColIx )
1220 ImplDrawColumnBackgr( nColIx );
1221
1222 ImplDrawRowHeaders();
1223 }
1224
1225 void ScCsvGrid::ImplDrawColumnSelection( sal_uInt32 nColIndex )
1226 {
1227 ImplInvertCursor( GetRulerCursorPos() );
1228 ImplSetColumnClipRegion( maGridDev, nColIndex );
1229 maGridDev.DrawOutDev( Point(), maWinSize, Point(), maWinSize, maBackgrDev );
1230
1231 if( IsSelected( nColIndex ) )
1232 {
1233 sal_Int32 nX1 = GetColumnX( nColIndex ) + 1;
1234 sal_Int32 nX2 = GetColumnX( nColIndex + 1 );
1235
1236 // header
1237 Rectangle aRect( nX1, 0, nX2, GetHdrHeight() );
1238 maGridDev.SetLineColor();
1239 if( maHeaderBackColor.IsDark() )
1240 // redraw with light gray background in dark mode
1241 ImplDrawColumnHeader( maGridDev, nColIndex, COL_LIGHTGRAY );
1242 else
1243 {
1244 // use transparent active color
1245 maGridDev.SetFillColor( maSelectColor );
1246 maGridDev.DrawTransparent( PolyPolygon( Polygon( aRect ) ), CSV_HDR_TRANSPARENCY );
1247 }
1248
1249 // column selection
1250 aRect = Rectangle( nX1, GetHdrHeight() + 1, nX2, GetY( GetLastVisLine() + 1 ) - 1 );
1251 ImplInvertRect( maGridDev, aRect );
1252 }
1253
1254 maGridDev.SetClipRegion();
1255 ImplInvertCursor( GetRulerCursorPos() );
1256 }
1257
1258 void ScCsvGrid::ImplDrawGridDev()
1259 {
1260 maGridDev.DrawOutDev( Point(), maWinSize, Point(), maWinSize, maBackgrDev );
1261 sal_uInt32 nLastCol = GetLastVisColumn();
1262 for( sal_uInt32 nColIx = GetFirstVisColumn(); nColIx <= nLastCol; ++nColIx )
1263 ImplDrawColumnSelection( nColIx );
1264 }
1265
1266 void ScCsvGrid::ImplDrawColumn( sal_uInt32 nColIndex )
1267 {
1268 ImplDrawColumnBackgr( nColIndex );
1269 ImplDrawColumnSelection( nColIndex );
1270 }
1271
1272 void ScCsvGrid::ImplDrawHorzScrolled( sal_Int32 nOldPos )
1273 {
1274 sal_Int32 nPos = GetFirstVisPos();
1275 if( !IsValidGfx() || (nPos == nOldPos) )
1276 return;
1277 if( Abs( nPos - nOldPos ) > GetVisPosCount() / 2 )
1278 {
1279 ImplDrawBackgrDev();
1280 ImplDrawGridDev();
1281 return;
1282 }
1283
1284 Point aSrc, aDest;
1285 sal_uInt32 nFirstColIx, nLastColIx;
1286 if( nPos < nOldPos )
1287 {
1288 aSrc = Point( GetFirstX() + 1, 0 );
1289 aDest = Point( GetFirstX() + GetCharWidth() * (nOldPos - nPos) + 1, 0 );
1290 nFirstColIx = GetColumnFromPos( nPos );
1291 nLastColIx = GetColumnFromPos( nOldPos );
1292 }
1293 else
1294 {
1295 aSrc = Point( GetFirstX() + GetCharWidth() * (nPos - nOldPos) + 1, 0 );
1296 aDest = Point( GetFirstX() + 1, 0 );
1297 nFirstColIx = GetColumnFromPos( Min( nOldPos + GetVisPosCount(), GetPosCount() ) - 1 );
1298 nLastColIx = GetColumnFromPos( Min( nPos + GetVisPosCount(), GetPosCount() ) - 1 );
1299 }
1300
1301 ImplInvertCursor( GetRulerCursorPos() + (nPos - nOldPos) );
1302 Rectangle aRectangle( GetFirstX(), 0, GetLastX(), GetHeight() - 1 );
1303 Region aClipReg( aRectangle );
1304 maBackgrDev.SetClipRegion( aClipReg );
1305 maBackgrDev.CopyArea( aDest, aSrc, maWinSize );
1306 maBackgrDev.SetClipRegion();
1307 maGridDev.SetClipRegion( aClipReg );
1308 maGridDev.CopyArea( aDest, aSrc, maWinSize );
1309 maGridDev.SetClipRegion();
1310 ImplInvertCursor( GetRulerCursorPos() );
1311
1312 for( sal_uInt32 nColIx = nFirstColIx; nColIx <= nLastColIx; ++nColIx )
1313 ImplDrawColumn( nColIx );
1314
1315 sal_Int32 nLastX = GetX( GetPosCount() ) + 1;
1316 if( nLastX <= GetLastX() )
1317 {
1318 Rectangle aRect( nLastX, 0, GetLastX(), GetHeight() - 1 );
1319 maBackgrDev.SetLineColor();
1320 maBackgrDev.SetFillColor( maAppBackColor );
1321 maBackgrDev.DrawRect( aRect );
1322 maGridDev.SetLineColor();
1323 maGridDev.SetFillColor( maAppBackColor );
1324 maGridDev.DrawRect( aRect );
1325 }
1326 }
1327
1328 void ScCsvGrid::ImplInvertCursor( sal_Int32 nPos )
1329 {
1330 if( IsVisibleSplitPos( nPos ) )
1331 {
1332 sal_Int32 nX = GetX( nPos ) - 1;
1333 Rectangle aRect( Point( nX, 0 ), Size( 3, GetHdrHeight() ) );
1334 ImplInvertRect( maGridDev, aRect );
1335 aRect.Top() = GetHdrHeight() + 1;
1336 aRect.Bottom() = GetY( GetLastVisLine() + 1 );
1337 ImplInvertRect( maGridDev, aRect );
1338 }
1339 }
1340
1341 void ScCsvGrid::ImplDrawTrackingRect( sal_uInt32 nColIndex )
1342 {
1343 if( HasFocus() && IsVisibleColumn( nColIndex ) )
1344 {
1345 sal_Int32 nX1 = Max( GetColumnX( nColIndex ), GetFirstX() ) + 1;
1346 sal_Int32 nX2 = Min( GetColumnX( nColIndex + 1 ) - sal_Int32( 1 ), GetLastX() );
1347 sal_Int32 nY2 = Min( GetY( GetLastVisLine() + 1 ), GetHeight() ) - 1;
1348 InvertTracking( Rectangle( nX1, 0, nX2, nY2 ), SHOWTRACK_SMALL | SHOWTRACK_WINDOW );
1349 }
1350 }
1351
1352
1353 // accessibility ==============================================================
1354
1355 ScAccessibleCsvControl* ScCsvGrid::ImplCreateAccessible()
1356 {
1357 return new ScAccessibleCsvGrid( *this );
1358 }
1359
1360
1361 // ============================================================================
1362
vba interoperability for OOo