1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sw.hxx"
26 #ifdef SW_DLLIMPLEMENTATION
27 #undef SW_DLLIMPLEMENTATION
28 #endif
29
30 #include "dbinsdlg.hxx"
31
32 #include <memory>
33
34 #include <float.h>
35
36 #include <hintids.hxx>
37 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
38 #include <com/sun/star/container/XNameAccess.hpp>
39 #include <com/sun/star/sdbc/XDataSource.hpp>
40 #include <com/sun/star/sdbc/XRow.hpp>
41 #include <com/sun/star/sdbcx/XTablesSupplier.hpp>
42 #include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
43 #include <com/sun/star/sdb/XQueriesSupplier.hpp>
44 #include <com/sun/star/sdb/CommandType.hpp>
45 #include <com/sun/star/sdb/XColumn.hpp>
46 #include <com/sun/star/sdb/XDatabaseAccess.hpp>
47 #include <com/sun/star/sdbc/DataType.hpp>
48 #include <com/sun/star/sdbc/ResultSetType.hpp>
49 #include <com/sun/star/beans/XPropertySet.hpp>
50 #include <com/sun/star/util/XNumberFormatter.hpp>
51 #include <com/sun/star/util/XNumberFormatTypes.hpp>
52 #include <com/sun/star/sdbc/XRowSet.hpp>
53 #include <comphelper/processfactory.hxx>
54 #include <editeng/langitem.hxx>
55 #include <svl/numuno.hxx>
56 #include <svl/stritem.hxx>
57 #include <vcl/msgbox.hxx>
58 #include <vcl/svapp.hxx>
59 #include <vcl/mnemonic.hxx>
60 #include <svl/style.hxx>
61 #include <svl/zformat.hxx>
62 #include <svx/htmlmode.hxx>
63 #include <editeng/unolingu.hxx>
64 #include <sfx2/app.hxx>
65 #include <svl/itemset.hxx>
66 #include <editeng/brshitem.hxx>
67 #include <editeng/boxitem.hxx>
68 #include <svx/rulritem.hxx>
69 #include <swdbtoolsclient.hxx>
70 #include <tabledlg.hxx>
71 #include <fmtclds.hxx>
72 #include <tabcol.hxx>
73 #include <uiitems.hxx>
74 #include <viewopt.hxx>
75 #include <uitool.hxx>
76 #include <wrtsh.hxx>
77 #include <wview.hxx>
78 #include <docsh.hxx>
79 #include <dbmgr.hxx>
80 #include <tblafmt.hxx>
81 #include <cellatr.hxx>
82 #include <swtable.hxx>
83 #include <dbfld.hxx>
84 #include <fmtcol.hxx>
85 #include <section.hxx>
86 #include <swwait.hxx>
87 #include <modcfg.hxx>
88 #include <swmodule.hxx>
89 #include <poolfmt.hxx>
90 #include <crsskip.hxx>
91
92 #include <dbinsdlg.hrc>
93 #include <dbui.hrc>
94
95 #include <cmdid.h>
96 #include <helpid.h>
97 #include <cfgid.h>
98 #include <SwStyleNameMapper.hxx>
99 #include <comphelper/uno3.hxx>
100 #include "tabsh.hxx"
101 #include "swabstdlg.hxx"
102 #include "table.hrc"
103 #include <unomid.h>
104 #include <IDocumentMarkAccess.hxx>
105
106
107 namespace swui
108 {
109 SwAbstractDialogFactory * GetFactory();
110 }
111
112 using namespace ::com::sun::star;
113 using namespace ::com::sun::star::uno;
114 using namespace ::com::sun::star::container;
115 using namespace ::com::sun::star::lang;
116 using namespace ::com::sun::star::sdb;
117 using namespace ::com::sun::star::sdbc;
118 using namespace ::com::sun::star::sdbcx;
119 using namespace ::com::sun::star::beans;
120
121 // tblafmt.hxx
122 SV_IMPL_PTRARR( _SwTableAutoFmtTbl, SwTableAutoFmt* )
123
124 const char cDBFldStart = '<';
125 const char cDBFldEnd = '>';
126
127 // Hilfsstruktur fuers einfuegen von Datenbankspalten als Felder oder Text
128 struct _DB_Column
129 {
130 enum ColType { DB_FILLTEXT, DB_COL_FIELD, DB_COL_TEXT, DB_SPLITPARA } eColType;
131
132 union {
133 String* pText;
134 SwField* pField;
135 sal_uLong nFormat;
136 } DB_ColumnData;
137 const SwInsDBColumn* pColInfo;
138
_DB_Column_DB_Column139 _DB_Column()
140 {
141 pColInfo = 0;
142 DB_ColumnData.pText = 0;
143 eColType = DB_SPLITPARA;
144 }
145
_DB_Column_DB_Column146 _DB_Column( const String& rTxt )
147 {
148 pColInfo = 0;
149 DB_ColumnData.pText = new String( rTxt );
150 eColType = DB_FILLTEXT;
151 }
152
_DB_Column_DB_Column153 _DB_Column( const SwInsDBColumn& rInfo, sal_uLong nFormat )
154 {
155 pColInfo = &rInfo;
156 DB_ColumnData.nFormat = nFormat;
157 eColType = DB_COL_TEXT;
158 }
159
_DB_Column_DB_Column160 _DB_Column( const SwInsDBColumn& rInfo, SwDBField& rFld )
161 {
162 pColInfo = &rInfo;
163 DB_ColumnData.pField = &rFld;
164 eColType = DB_COL_FIELD;
165 }
166
~_DB_Column_DB_Column167 ~_DB_Column()
168 {
169 if( DB_COL_FIELD == eColType )
170 delete DB_ColumnData.pField;
171 else if( DB_FILLTEXT == eColType )
172 delete DB_ColumnData.pText;
173 }
174 };
175
176 typedef _DB_Column* _DB_ColumnPtr;
177 SV_DECL_PTRARR_DEL( _DB_Columns, _DB_ColumnPtr, 32, 32 )
178 SV_IMPL_PTRARR( _DB_Columns, _DB_ColumnPtr )
179
180 SV_IMPL_OP_PTRARR_SORT( SwInsDBColumns, SwInsDBColumnPtr )
181
182 /* */
183
184 #define DBCOLUMN_CONFIG_VERSION1 1
185 #define DBCOLUMN_CONFIG_VERSION DBCOLUMN_CONFIG_VERSION1
186 #define DBCOLUMN_MAXDATA 5
187
188 struct _DB_ColumnConfigData
189 {
190 SwInsDBColumns aDBColumns;
191 rtl::OUString sSource, sTable, sEdit, sTblList, sTmplNm, sTAutoFmtNm;
192 sal_Bool bIsTable : 1,
193 bIsField : 1,
194 bIsHeadlineOn : 1,
195 bIsEmptyHeadln : 1;
196
_DB_ColumnConfigData_DB_ColumnConfigData197 _DB_ColumnConfigData()
198 {
199 bIsTable = bIsHeadlineOn = sal_True;
200 bIsField = bIsEmptyHeadln = sal_False;
201 }
202
203 ~_DB_ColumnConfigData();
204 private:
205 _DB_ColumnConfigData( const _DB_ColumnConfigData& );
206 _DB_ColumnConfigData& operator =( const _DB_ColumnConfigData& );
207 };
208
209 /* */
210
operator <(const SwInsDBColumn & rCmp) const211 int SwInsDBColumn::operator<( const SwInsDBColumn& rCmp ) const
212 {
213 return 0 > GetAppCollator().compareString( sColumn, rCmp.sColumn );
214 }
215 /* ---------------------------------------------------------------------------
216
217 ---------------------------------------------------------------------------*/
SwInsertDBColAutoPilot(SwView & rView,Reference<XDataSource> xDataSource,Reference<sdbcx::XColumnsSupplier> xColSupp,const SwDBData & rData)218 SwInsertDBColAutoPilot::SwInsertDBColAutoPilot( SwView& rView,
219 Reference<XDataSource> xDataSource,
220 Reference<sdbcx::XColumnsSupplier> xColSupp,
221 const SwDBData& rData )
222 : SfxModalDialog( rView.GetWindow(), SW_RES( DLG_AP_INSERT_DB_SEL )),
223 ConfigItem(C2U("Office.Writer/InsertData/DataSet"), CONFIG_MODE_DELAYED_UPDATE),
224 aFtInsertData( this, SW_RES( FT_INSERT_DATA )),
225 aRbAsTable( this, SW_RES( RB_AS_TABLE )),
226 aRbAsField( this, SW_RES( RB_AS_FIELD )),
227 aRbAsText( this, SW_RES( RB_AS_TEXT )),
228
229 aFlHead( this, SW_RES( FL_HEAD )),
230 aFtDbColumn( this, SW_RES( FT_DB_COLUMN )),
231
232 aLbTblDbColumn( this, SW_RES( LB_TBL_DB_COLUMN )),
233 aLbTxtDbColumn( this, SW_RES( LB_TXT_DB_COLUMN )),
234
235 aFlFormat( this, SW_RES( FL_FORMAT )),
236 aRbDbFmtFromDb( this, SW_RES( RB_DBFMT_FROM_DB )),
237 aRbDbFmtFromUsr( this, SW_RES( RB_DBFMT_FROM_USR )),
238 aLbDbFmtFromUsr( this, &rView, SW_RES( LB_DBFMT_FROM_USR )),
239
240 aIbDbcolToEdit( this, SW_RES( IB_DBCOL_TOEDIT )),
241 aEdDbText( this, SW_RES( ED_DB_TEXT )),
242 aFtDbParaColl( this, SW_RES( FT_DB_PARA_COLL )),
243 aLbDbParaColl( this, SW_RES( LB_DB_PARA_COLL )),
244
245 aIbDbcolAllTo( this, SW_RES( IB_DBCOL_ALL_TO )),
246 aIbDbcolOneTo( this, SW_RES( IB_DBCOL_ONE_TO )),
247 aIbDbcolOneFrom( this, SW_RES( IB_DBCOL_ONE_FROM )),
248 aIbDbcolAllFrom( this, SW_RES( IB_DBCOL_ALL_FROM )),
249 aFtTableCol( this, SW_RES( FT_TABLE_COL )),
250 aLbTableCol( this, SW_RES( LB_TABLE_COL )),
251 aCbTableHeadon( this, SW_RES( CB_TABLE_HEADON )),
252 aRbHeadlColnms( this, SW_RES( RB_HEADL_COLNMS )),
253 aRbHeadlEmpty( this, SW_RES( RB_HEADL_EMPTY )),
254 aPbTblFormat( this, SW_RES( PB_TBL_FORMAT )),
255 aPbTblAutofmt( this, SW_RES( PB_TBL_AUTOFMT )),
256
257 aBtOk( this, SW_RES( BT_OK )),
258 aBtCancel( this, SW_RES( BT_CANCEL )),
259 aBtHelp( this, SW_RES( BT_HELP )),
260
261 aFlBottom( this, SW_RES( FL_BOTTOM )),
262
263 aDBData(rData),
264
265 aOldNumFmtLnk( aLbDbFmtFromUsr.GetSelectHdl() ),
266 sNoTmpl( SW_RES( STR_NOTEMPL )),
267 pView( &rView ),
268 pTAutoFmt( 0 ),
269 pTblSet( 0 ),
270 pRep( 0 )
271 {
272 FreeResource();
273
274 nGBFmtLen = aFlFormat.GetText().Len();
275
276 if(xColSupp.is())
277 {
278 SwWrtShell& rSh = pView->GetWrtShell();
279 Locale aDocLocale( SvxCreateLocale( rSh.GetCurLang() ));
280 SvNumberFormatter* pNumFmtr = rSh.GetNumberFormatter();
281 SvNumberFormatsSupplierObj* pNumFmt = new SvNumberFormatsSupplierObj( pNumFmtr );
282 Reference< util::XNumberFormatsSupplier > xDocNumFmtsSupplier = pNumFmt;
283 Reference< util::XNumberFormats > xDocNumberFormats = xDocNumFmtsSupplier->getNumberFormats();
284 Reference< util::XNumberFormatTypes > xDocNumberFormatTypes(xDocNumberFormats, UNO_QUERY);
285
286 Reference<XPropertySet> xSourceProps(xDataSource, UNO_QUERY);
287 Reference< util::XNumberFormats > xNumberFormats;
288 if(xSourceProps.is())
289 {
290 Any aFormats = xSourceProps->getPropertyValue(C2U("NumberFormatsSupplier"));
291 if(aFormats.hasValue())
292 {
293 Reference< util::XNumberFormatsSupplier> xSuppl;
294 aFormats >>= xSuppl;
295 if(xSuppl.is())
296 {
297 xNumberFormats = xSuppl->getNumberFormats( );
298 }
299 }
300 }
301 Reference <XNameAccess> xCols = xColSupp->getColumns();
302 Sequence<rtl::OUString> aColNames = xCols->getElementNames();
303 const rtl::OUString* pColNames = aColNames.getConstArray();
304 long nCount = aColNames.getLength();
305 for (long n = 0; n < nCount; n++)
306 {
307 SwInsDBColumn* pNew = new SwInsDBColumn( pColNames[n], (sal_uInt16)n );
308 Any aCol = xCols->getByName(pColNames[n]);
309 Reference <XPropertySet> xCol;
310 aCol >>= xCol;
311 Any aType = xCol->getPropertyValue(C2S("Type"));
312 sal_Int32 eDataType = 0;
313 aType >>= eDataType;
314 switch(eDataType)
315 {
316 case DataType::BIT:
317 case DataType::BOOLEAN:
318 case DataType::TINYINT:
319 case DataType::SMALLINT:
320 case DataType::INTEGER:
321 case DataType::BIGINT:
322 case DataType::FLOAT:
323 case DataType::REAL:
324 case DataType::DOUBLE:
325 case DataType::NUMERIC:
326 case DataType::DECIMAL:
327 case DataType::DATE:
328 case DataType::TIME:
329 case DataType::TIMESTAMP:
330 {
331 pNew->bHasFmt = sal_True;
332 Any aFormat = xCol->getPropertyValue(C2U("FormatKey"));
333 if(aFormat.hasValue())
334 {
335 sal_Int32 nFmt = 0;
336 aFormat >>= nFmt;
337 if(xNumberFormats.is())
338 {
339 try
340 {
341 Reference<XPropertySet> xNumProps = xNumberFormats->getByKey( nFmt );
342 Any aFormatVal = xNumProps->getPropertyValue(C2U("FormatString"));
343 Any aLocale = xNumProps->getPropertyValue(C2U("Locale"));
344 rtl::OUString sFormat;
345 aFormatVal >>= sFormat;
346 lang::Locale aLoc;
347 aLocale >>= aLoc;
348 long nKey = xDocNumberFormats->queryKey( sFormat, aLoc, sal_True);
349 if(nKey < 0)
350 {
351 nKey = xDocNumberFormats->addNew( sFormat, aLoc );
352 }
353 pNew->nDBNumFmt = nKey;
354 }
355 catch(const Exception& )
356 {
357 DBG_ERROR("illegal number format key");
358 }
359 }
360 }
361 else
362 {
363 pNew->nDBNumFmt = SwNewDBMgr::GetDbtoolsClient().getDefaultNumberFormat(xCol,
364 xDocNumberFormatTypes, aDocLocale);
365 }
366
367 }
368 break;
369 }
370 if( !aDBColumns.Insert( pNew ))
371 {
372 ASSERT( !this, "Spaltenname mehrfach vergeben?" );
373 delete pNew;
374 }
375 }
376 }
377
378 // Absatzvorlagen-ListBox fuellen
379 {
380 SfxStyleSheetBasePool* pPool = pView->GetDocShell()->GetStyleSheetPool();
381 pPool->SetSearchMask( SFX_STYLE_FAMILY_PARA, SFXSTYLEBIT_ALL );
382 aLbDbParaColl.InsertEntry( sNoTmpl );
383
384 const SfxStyleSheetBase* pBase = pPool->First();
385 while( pBase )
386 {
387 aLbDbParaColl.InsertEntry( pBase->GetName() );
388 pBase = pPool->Next();
389 }
390 aLbDbParaColl.SelectEntryPos( 0 );
391 }
392
393 // steht der Cursor in einer Tabelle, darf NIE Tabelle auswaehlbar sein
394 if( pView->GetWrtShell().GetTableFmt() )
395 {
396 aRbAsTable.Enable( sal_False );
397 aRbAsField.Check( sal_True );
398 aRbDbFmtFromDb.Check( sal_True );
399 }
400 else
401 {
402 aRbAsTable.Check( sal_True );
403 aRbDbFmtFromDb.Check( sal_True );
404 aIbDbcolOneFrom.Enable( sal_False );
405 aIbDbcolAllFrom.Enable( sal_False );
406 }
407
408 aRbAsTable.SetClickHdl( LINK(this, SwInsertDBColAutoPilot, PageHdl ));
409 aRbAsField.SetClickHdl( LINK(this, SwInsertDBColAutoPilot, PageHdl ));
410 aRbAsText.SetClickHdl( LINK(this, SwInsertDBColAutoPilot, PageHdl ));
411
412 aRbDbFmtFromDb.SetClickHdl( LINK(this, SwInsertDBColAutoPilot, DBFormatHdl ));
413 aRbDbFmtFromUsr.SetClickHdl( LINK(this, SwInsertDBColAutoPilot, DBFormatHdl ));
414
415 aPbTblFormat.SetClickHdl(LINK(this, SwInsertDBColAutoPilot, TblFmtHdl ));
416 aPbTblAutofmt.SetClickHdl(LINK(this, SwInsertDBColAutoPilot, AutoFmtHdl ));
417
418 aIbDbcolAllTo.SetClickHdl( LINK(this, SwInsertDBColAutoPilot, TblToFromHdl ));
419 aIbDbcolOneTo.SetClickHdl( LINK(this, SwInsertDBColAutoPilot, TblToFromHdl ));
420 aIbDbcolOneFrom.SetClickHdl( LINK(this, SwInsertDBColAutoPilot, TblToFromHdl ));
421 aIbDbcolAllFrom.SetClickHdl( LINK(this, SwInsertDBColAutoPilot, TblToFromHdl ));
422 aIbDbcolToEdit.SetClickHdl( LINK(this, SwInsertDBColAutoPilot, TblToFromHdl ));
423
424 aCbTableHeadon.SetClickHdl( LINK(this, SwInsertDBColAutoPilot, HeaderHdl ));
425 aRbHeadlColnms.SetClickHdl( LINK(this, SwInsertDBColAutoPilot, HeaderHdl ));
426 aRbHeadlEmpty.SetClickHdl( LINK(this, SwInsertDBColAutoPilot, HeaderHdl ));
427
428 aLbTxtDbColumn.SetSelectHdl( LINK( this, SwInsertDBColAutoPilot, SelectHdl ));
429 aLbTblDbColumn.SetSelectHdl( LINK( this, SwInsertDBColAutoPilot, SelectHdl ));
430 aLbDbFmtFromUsr.SetSelectHdl( LINK( this, SwInsertDBColAutoPilot, SelectHdl ));
431 aLbTableCol.SetSelectHdl( LINK( this, SwInsertDBColAutoPilot, SelectHdl ));
432
433 aLbTxtDbColumn.SetDoubleClickHdl( LINK( this, SwInsertDBColAutoPilot, DblClickHdl ));
434 aLbTblDbColumn.SetDoubleClickHdl( LINK( this, SwInsertDBColAutoPilot, DblClickHdl ));
435 aLbTableCol.SetDoubleClickHdl( LINK( this, SwInsertDBColAutoPilot, DblClickHdl ));
436
437 for( sal_uInt16 n = 0; n < aDBColumns.Count(); ++n )
438 {
439 const String& rS = aDBColumns[ n ]->sColumn;
440 aLbTblDbColumn.InsertEntry( rS, n );
441 aLbTxtDbColumn.InsertEntry( rS, n );
442 }
443 aLbTxtDbColumn.SelectEntryPos( 0 );
444 aLbTblDbColumn.SelectEntryPos( 0 );
445
446 // read configuration
447 Load();
448
449 // Controls initialisieren:
450 PageHdl( aRbAsTable.IsChecked() ? &aRbAsTable : &aRbAsField );
451 }
452 /* ---------------------------------------------------------------------------
453
454 ---------------------------------------------------------------------------*/
~SwInsertDBColAutoPilot()455 SwInsertDBColAutoPilot::~SwInsertDBColAutoPilot()
456 {
457 delete pTblSet;
458 delete pRep;
459
460 // delete pConfig;
461 delete pTAutoFmt;
462 }
463 /* ---------------------------------------------------------------------------
464
465 ---------------------------------------------------------------------------*/
IMPL_LINK(SwInsertDBColAutoPilot,PageHdl,Button *,pButton)466 IMPL_LINK( SwInsertDBColAutoPilot, PageHdl, Button*, pButton )
467 {
468 sal_Bool bShowTbl = pButton == &aRbAsTable;
469
470 String sTxt( pButton->GetText() );
471 aFlHead.SetText( MnemonicGenerator::EraseAllMnemonicChars( sTxt ) );
472
473 aLbTxtDbColumn.Show( !bShowTbl );
474 aIbDbcolToEdit.Show( !bShowTbl );
475 aEdDbText.Show( !bShowTbl );
476 aFtDbParaColl.Show( !bShowTbl );
477 aLbDbParaColl.Show( !bShowTbl );
478
479 aLbTblDbColumn.Show( bShowTbl );
480 aIbDbcolAllTo.Show( bShowTbl );
481 aIbDbcolOneTo.Show( bShowTbl );
482 aIbDbcolOneFrom.Show( bShowTbl );
483 aIbDbcolAllFrom.Show( bShowTbl );
484 aFtTableCol.Show( bShowTbl );
485 aLbTableCol.Show( bShowTbl );
486 aCbTableHeadon.Show( bShowTbl );
487 aRbHeadlColnms.Show( bShowTbl );
488 aRbHeadlEmpty.Show( bShowTbl );
489 aPbTblFormat.Show( bShowTbl );
490 aPbTblAutofmt.Show( bShowTbl );
491
492 if( bShowTbl )
493 aPbTblFormat.Enable( 0 != aLbTableCol.GetEntryCount() );
494
495 SelectHdl( bShowTbl ? &aLbTblDbColumn : &aLbTxtDbColumn );
496
497 return 0;
498 }
499 /* ---------------------------------------------------------------------------
500
501 ---------------------------------------------------------------------------*/
IMPL_LINK(SwInsertDBColAutoPilot,DBFormatHdl,Button *,pButton)502 IMPL_LINK( SwInsertDBColAutoPilot, DBFormatHdl, Button*, pButton )
503 {
504 sal_uInt16 nFndPos;
505 ListBox& rBox = aRbAsTable.IsChecked()
506 ? ( 0 == aLbTableCol.GetEntryData( 0 )
507 ? aLbTblDbColumn
508 : aLbTableCol )
509 : aLbTxtDbColumn;
510
511 SwInsDBColumn aSrch( rBox.GetSelectEntry(), 0 );
512 aDBColumns.Seek_Entry( &aSrch, &nFndPos );
513
514 sal_Bool bFromDB = &aRbDbFmtFromDb == pButton;
515 aDBColumns[ nFndPos ]->bIsDBFmt = bFromDB;
516 aLbDbFmtFromUsr.Enable( !bFromDB );
517
518 return 0;
519 }
520 /* ---------------------------------------------------------------------------
521
522 ---------------------------------------------------------------------------*/
IMPL_LINK(SwInsertDBColAutoPilot,TblToFromHdl,Button *,pButton)523 IMPL_LINK( SwInsertDBColAutoPilot, TblToFromHdl, Button*, pButton )
524 {
525 sal_Bool bChgEnable = sal_True, bEnableTo = sal_True, bEnableFrom = sal_True;
526 aLbTblDbColumn.SetUpdateMode( sal_False );
527 aLbTableCol.SetUpdateMode( sal_False );
528
529 if( pButton == &aIbDbcolAllTo )
530 {
531 bEnableTo = sal_False;
532
533 sal_uInt16 n, nInsPos = aLbTableCol.GetSelectEntryPos(),
534 nCnt = aLbTblDbColumn.GetEntryCount();
535 if( LISTBOX_APPEND == nInsPos )
536 for( n = 0; n < nCnt; ++n )
537 aLbTableCol.InsertEntry( aLbTblDbColumn.GetEntry( n ),
538 LISTBOX_APPEND );
539 else
540 for( n = 0; n < nCnt; ++n, ++nInsPos )
541 aLbTableCol.InsertEntry( aLbTblDbColumn.GetEntry( n ), nInsPos );
542 aLbTblDbColumn.Clear();
543 aLbTableCol.SelectEntryPos( nInsPos );
544 aLbTblDbColumn.SelectEntryPos( LISTBOX_APPEND );
545 }
546 else if( pButton == &aIbDbcolOneTo &&
547 LISTBOX_ENTRY_NOTFOUND != aLbTblDbColumn.GetSelectEntryPos() )
548 {
549 sal_uInt16 nInsPos = aLbTableCol.GetSelectEntryPos(),
550 nDelPos = aLbTblDbColumn.GetSelectEntryPos(),
551 nTopPos = aLbTblDbColumn.GetTopEntry();
552 aLbTableCol.InsertEntry( aLbTblDbColumn.GetEntry( nDelPos ), nInsPos );
553 aLbTblDbColumn.RemoveEntry( nDelPos );
554
555 aLbTableCol.SelectEntryPos( nInsPos );
556 if( nDelPos >= aLbTblDbColumn.GetEntryCount() )
557 nDelPos = aLbTblDbColumn.GetEntryCount() - 1;
558 aLbTblDbColumn.SelectEntryPos( nDelPos );
559 aLbTblDbColumn.SetTopEntry( nTopPos );
560
561 bEnableTo = 0 != aLbTblDbColumn.GetEntryCount();
562 }
563 else if( pButton == &aIbDbcolOneFrom )
564 {
565 if( LISTBOX_ENTRY_NOTFOUND != aLbTableCol.GetSelectEntryPos() )
566 {
567 sal_uInt16 nFndPos, nInsPos,
568 nDelPos = aLbTableCol.GetSelectEntryPos(),
569 nTopPos = aLbTableCol.GetTopEntry();
570
571 // die richtige InsertPos suchen!!
572 SwInsDBColumn aSrch( aLbTableCol.GetEntry( nDelPos ), 0 );
573 aDBColumns.Seek_Entry( &aSrch, &nFndPos );
574 if( !nFndPos || nFndPos == aDBColumns.Count()-1 )
575 nInsPos = nFndPos;
576 else
577 {
578 nInsPos = LISTBOX_ENTRY_NOTFOUND;
579 while( ++nFndPos < aDBColumns.Count() &&
580 LISTBOX_ENTRY_NOTFOUND == (nInsPos = aLbTblDbColumn.
581 GetEntryPos( String(aDBColumns[ nFndPos ]->sColumn ))) )
582 ;
583 }
584
585 aLbTblDbColumn.InsertEntry( aSrch.sColumn, nInsPos );
586 aLbTableCol.RemoveEntry( nDelPos );
587
588 if( nInsPos >= aLbTblDbColumn.GetEntryCount() )
589 nInsPos = aLbTblDbColumn.GetEntryCount() - 1;
590 aLbTblDbColumn.SelectEntryPos( nInsPos );
591
592 if( nDelPos >= aLbTableCol.GetEntryCount() )
593 nDelPos = aLbTableCol.GetEntryCount() - 1;
594 aLbTableCol.SelectEntryPos( nDelPos );
595 aLbTableCol.SetTopEntry( nTopPos );
596 }
597 else
598 bEnableTo = 0 != aLbTblDbColumn.GetEntryCount();
599
600 bEnableFrom = 0 != aLbTableCol.GetEntryCount();
601 }
602 else if( pButton == &aIbDbcolAllFrom )
603 {
604 bEnableFrom = sal_False;
605
606 aLbTblDbColumn.Clear();
607 aLbTableCol.Clear();
608 for( sal_uInt16 n = 0; n < aDBColumns.Count(); ++n )
609 aLbTblDbColumn.InsertEntry( aDBColumns[ n ]->sColumn, n );
610 aLbTblDbColumn.SelectEntryPos( 0 );
611 }
612 else if( pButton == &aIbDbcolToEdit )
613 {
614 bChgEnable = sal_False;
615 // Daten ins Edit moven:
616 String aFld( aLbTxtDbColumn.GetSelectEntry() );
617 if( aFld.Len() )
618 {
619 String aStr( aEdDbText.GetText() );
620 sal_uInt16 nPos = (sal_uInt16)aEdDbText.GetSelection().Min();
621 sal_uInt16 nSel = sal_uInt16(aEdDbText.GetSelection().Max()) - nPos;
622 if( nSel )
623 // dann loesche erstmal die bestehende Selektion
624 aStr.Erase( nPos, nSel );
625
626 aFld.Insert( cDBFldStart, 0 );
627 aFld += cDBFldEnd;
628 if( aStr.Len() )
629 {
630 if( nPos ) // ein Space davor
631 {
632 sal_Unicode c = aStr.GetChar( nPos-1 );
633 if( '\n' != c && '\r' != c )
634 aFld.Insert( ' ', 0 );
635 }
636 if( nPos < aStr.Len() ) // ein Space dahinter
637 {
638 sal_Unicode c = aStr.GetChar( nPos );
639 if( '\n' != c && '\r' != c )
640 aFld += ' ';
641 }
642 }
643
644 aStr.Insert( aFld, nPos );
645 aEdDbText.SetText( aStr );
646 nPos = nPos + aFld.Len();
647 aEdDbText.SetSelection( Selection( nPos ));
648 }
649 }
650
651 if( bChgEnable )
652 {
653 aIbDbcolOneTo.Enable( bEnableTo );
654 aIbDbcolAllTo.Enable( bEnableTo );
655 aIbDbcolOneFrom.Enable( bEnableFrom );
656 aIbDbcolAllFrom.Enable( bEnableFrom );
657
658 aRbDbFmtFromDb.Enable( sal_False );
659 aRbDbFmtFromUsr.Enable( sal_False );
660 aLbDbFmtFromUsr.Enable( sal_False );
661
662 aPbTblFormat.Enable( bEnableFrom );
663 }
664 aLbTblDbColumn.SetUpdateMode( sal_True );
665 aLbTableCol.SetUpdateMode( sal_True );
666
667 return 0;
668 }
669 /* ---------------------------------------------------------------------------
670
671 ---------------------------------------------------------------------------*/
IMPL_LINK(SwInsertDBColAutoPilot,DblClickHdl,ListBox *,pBox)672 IMPL_LINK( SwInsertDBColAutoPilot, DblClickHdl, ListBox*, pBox )
673 {
674 Button* pButton = 0;
675 if( pBox == &aLbTxtDbColumn )
676 pButton = &aIbDbcolToEdit;
677 else if( pBox == &aLbTblDbColumn && aIbDbcolOneTo.IsEnabled() )
678 pButton = &aIbDbcolOneTo;
679 else if( pBox == &aLbTableCol && aIbDbcolOneFrom.IsEnabled() )
680 pButton = &aIbDbcolOneFrom;
681
682 if( pButton )
683 TblToFromHdl( pButton );
684
685 return 0;
686 }
687 /* ---------------------------------------------------------------------------
688
689 ---------------------------------------------------------------------------*/
IMPL_LINK(SwInsertDBColAutoPilot,TblFmtHdl,PushButton *,pButton)690 IMPL_LINK( SwInsertDBColAutoPilot, TblFmtHdl, PushButton*, pButton )
691 {
692 SwWrtShell& rSh = pView->GetWrtShell();
693 sal_Bool bNewSet = sal_False;
694 if( !pTblSet )
695 {
696 bNewSet = sal_True;
697 pTblSet = new SfxItemSet( rSh.GetAttrPool(), SwuiGetUITableAttrRange() );
698
699 //Ersteinmal die einfachen Attribute besorgen.
700 pTblSet->Put( SfxStringItem( FN_PARAM_TABLE_NAME, rSh.GetUniqueTblName() ));
701 pTblSet->Put( SfxUInt16Item( FN_PARAM_TABLE_HEADLINE, 1 ) );
702
703 pTblSet->Put( SfxUInt16Item( SID_BACKGRND_DESTINATION,
704 rSh.GetViewOptions()->GetTblDest() ));
705
706 SvxBrushItem aBrush( RES_BACKGROUND );
707 pTblSet->Put( aBrush );
708 pTblSet->Put( aBrush, SID_ATTR_BRUSH_ROW );
709 pTblSet->Put( aBrush, SID_ATTR_BRUSH_TABLE );
710
711 SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER );
712 // Tabellenvariante, wenn mehrere Tabellenzellen selektiert
713 aBoxInfo.SetTable( sal_True );
714 // Abstandsfeld immer anzeigen
715 aBoxInfo.SetDist( sal_True);
716 // Minimalgroesse in Tabellen und Absaetzen setzen
717 aBoxInfo.SetMinDist( sal_False );
718 // Default-Abstand immer setzen
719 aBoxInfo.SetDefDist( MIN_BORDER_DIST );
720 // Einzelne Linien koennen nur in Tabellen DontCare-Status haben
721 aBoxInfo.SetValid( VALID_DISABLE, sal_True );
722 pTblSet->Put( aBoxInfo );
723
724 SwGetCurColNumPara aPara;
725 const sal_uInt16 nNum = rSh.GetCurColNum( &aPara );
726 long nWidth;
727
728 if( nNum )
729 {
730 nWidth = aPara.pPrtRect->Width();
731 const SwFmtCol& rCol = aPara.pFrmFmt->GetCol();
732 const SwColumns& rCols = rCol.GetColumns();
733
734 //nStart und nEnd initialisieren fuer nNum == 0
735 long nWidth1 = 0,
736 nStart1 = 0,
737 nEnd1 = nWidth;
738 for( sal_uInt16 i = 0; i < nNum; ++i )
739 {
740 SwColumn* pCol = rCols[i];
741 nStart1 = pCol->GetLeft() + nWidth1;
742 nWidth1 += (long)rCol.CalcColWidth( i, (sal_uInt16)nWidth );
743 nEnd1 = nWidth1 - pCol->GetRight();
744 }
745 if(nStart1 || nEnd1 != nWidth)
746 nWidth = nEnd1 - nStart1;
747 }
748 else
749 nWidth = rSh.GetAnyCurRect(
750 FRMTYPE_FLY_ANY & rSh.GetFrmType( 0, sal_True )
751 ? RECT_FLY_PRT_EMBEDDED
752 : RECT_PAGE_PRT ).Width();
753
754 SwTabCols aTabCols;
755 aTabCols.SetRight( nWidth );
756 aTabCols.SetRightMax( nWidth );
757 pRep = new SwTableRep( aTabCols, sal_False );
758 pRep->SetAlign( text::HoriOrientation::NONE );
759 pRep->SetSpace( nWidth );
760 pRep->SetWidth( nWidth );
761 pRep->SetWidthPercent( 100 );
762 pTblSet->Put( SwPtrItem( FN_TABLE_REP, pRep ));
763
764 pTblSet->Put( SfxUInt16Item( SID_HTML_MODE,
765 ::GetHtmlMode( pView->GetDocShell() )));
766 }
767
768 if( aLbTableCol.GetEntryCount() != pRep->GetAllColCount() )
769 {
770 // Anzahl der Spalten hat sich geaendert: dann muessen die
771 // TabCols angepasst werden
772 long nWidth = pRep->GetWidth();
773 sal_uInt16 nCols = aLbTableCol.GetEntryCount() - 1;
774 SwTabCols aTabCols( nCols );
775 aTabCols.SetRight( nWidth );
776 aTabCols.SetRightMax( nWidth );
777 if( nCols )
778 for( sal_uInt16 n = 0, nStep = (sal_uInt16)(nWidth / (nCols+1)), nW = nStep;
779 n < nCols; ++n, nW = nW + nStep )
780 {
781 aTabCols.Insert( nW, sal_False, n );
782 }
783 delete pRep;
784 pRep = new SwTableRep( aTabCols, sal_False );
785 pRep->SetAlign( text::HoriOrientation::NONE );
786 pRep->SetSpace( nWidth );
787 pRep->SetWidth( nWidth );
788 pRep->SetWidthPercent( 100 );
789 pTblSet->Put( SwPtrItem( FN_TABLE_REP, pRep ));
790 }
791
792 SwAbstractDialogFactory* pFact = swui::GetFactory();
793 DBG_ASSERT(pFact, "SwAbstractDialogFactory fail!");
794
795 SfxAbstractTabDialog* pDlg = pFact->CreateSwTableTabDlg( pButton, rSh.GetAttrPool(),pTblSet, &rSh, DLG_FORMAT_TABLE );
796 DBG_ASSERT(pDlg, "Dialogdiet fail!");
797 if( RET_OK == pDlg->Execute() )
798 pTblSet->Put( *pDlg->GetOutputItemSet() );
799 else if( bNewSet )
800 {
801 delete pTblSet, pTblSet = 0;
802 delete pRep, pRep = 0;
803 }
804 delete pDlg;
805
806 return 0;
807 }
808 /* ---------------------------------------------------------------------------
809
810 ---------------------------------------------------------------------------*/
IMPL_LINK(SwInsertDBColAutoPilot,AutoFmtHdl,PushButton *,pButton)811 IMPL_LINK( SwInsertDBColAutoPilot, AutoFmtHdl, PushButton*, pButton )
812 {
813 SwAbstractDialogFactory* pFact = swui::GetFactory();
814 DBG_ASSERT(pFact, "SwAbstractDialogFactory fail!");
815
816 AbstractSwAutoFormatDlg* pDlg = pFact->CreateSwAutoFormatDlg(pButton, pView->GetWrtShellPtr(),DLG_AUTOFMT_TABLE, sal_False, pTAutoFmt);
817 DBG_ASSERT(pDlg, "Dialogdiet fail!");
818 if( RET_OK == pDlg->Execute())
819 pDlg->FillAutoFmtOfIndex( pTAutoFmt );
820 delete pDlg;
821 return 0;
822 }
823 /* ---------------------------------------------------------------------------
824
825 ---------------------------------------------------------------------------*/
IMPL_LINK(SwInsertDBColAutoPilot,SelectHdl,ListBox *,pBox)826 IMPL_LINK( SwInsertDBColAutoPilot, SelectHdl, ListBox*, pBox )
827 {
828 ListBox* pGetBox = pBox == &aLbDbFmtFromUsr
829 ? ( aRbAsTable.IsChecked()
830 ? ( 0 == aLbTableCol.GetEntryData( 0 )
831 ? &aLbTblDbColumn
832 : &aLbTableCol )
833 : &aLbTxtDbColumn )
834 : pBox;
835
836 sal_uInt16 nFndPos;
837 SwInsDBColumn aSrch( pGetBox->GetSelectEntry(), 0 );
838 aDBColumns.Seek_Entry( &aSrch, &nFndPos );
839
840 if( pBox == &aLbDbFmtFromUsr )
841 {
842 if( aSrch.sColumn.getLength() )
843 {
844 aOldNumFmtLnk.Call( pBox );
845 aDBColumns[ nFndPos ]->nUsrNumFmt = aLbDbFmtFromUsr.GetFormat();
846 }
847 }
848 else
849 {
850 // an der FormatGroupBox den ausgewaehlten FeldNamen setzen, damit
851 // klar ist, welches Feld ueber das Format eingestellt wird!
852 String sTxt( aFlFormat.GetText().Copy( 0, nGBFmtLen ));
853 if( !aSrch.sColumn.getLength() )
854 {
855 aRbDbFmtFromDb.Enable( sal_False );
856 aRbDbFmtFromUsr.Enable( sal_False );
857 aLbDbFmtFromUsr.Enable( sal_False );
858 }
859 else
860 {
861 sal_Bool bEnableFmt = aDBColumns[ nFndPos ]->bHasFmt;
862 aRbDbFmtFromDb.Enable( bEnableFmt );
863 aRbDbFmtFromUsr.Enable( bEnableFmt );
864
865 if( bEnableFmt )
866 {
867 (( sTxt += C2S(" (" )) += String(aSrch.sColumn) ) += (sal_Unicode)')';
868 }
869
870 sal_Bool bIsDBFmt = aDBColumns[ nFndPos ]->bIsDBFmt;
871 aRbDbFmtFromDb.Check( bIsDBFmt );
872 aRbDbFmtFromUsr.Check( !bIsDBFmt );
873 aLbDbFmtFromUsr.Enable( !bIsDBFmt );
874 if( !bIsDBFmt )
875 aLbDbFmtFromUsr.SetDefFormat( aDBColumns[ nFndPos ]->nUsrNumFmt );
876 }
877
878 aFlFormat.SetText( sTxt );
879
880 // um spaeter zu wissen, welche ListBox die "aktive" war, wird sich
881 // im 1. Eintrag ein Flag gemerkt,
882 void* pPtr = pBox == &aLbTableCol ? &aLbTableCol : 0;
883 aLbTableCol.SetEntryData( 0, pPtr );
884 }
885 return 0;
886 }
887 /* ---------------------------------------------------------------------------
888
889 ---------------------------------------------------------------------------*/
IMPL_LINK(SwInsertDBColAutoPilot,HeaderHdl,Button *,pButton)890 IMPL_LINK( SwInsertDBColAutoPilot, HeaderHdl, Button*, pButton )
891 {
892 if( pButton == &aCbTableHeadon )
893 {
894 sal_Bool bEnable = aCbTableHeadon.IsChecked();
895
896 aRbHeadlColnms.Enable( bEnable );
897 aRbHeadlEmpty.Enable( bEnable );
898 }
899 return 0;
900 }
901 /* ---------------------------------------------------------------------------
902
903 ---------------------------------------------------------------------------*/
lcl_InsTextInArr(const String & rTxt,_DB_Columns & rColArr)904 static void lcl_InsTextInArr( const String& rTxt, _DB_Columns& rColArr )
905 {
906 _DB_Column* pNew;
907 sal_uInt16 nSttPos = 0, nFndPos;
908 while( STRING_NOTFOUND != ( nFndPos = rTxt.Search( '\x0A', nSttPos )) )
909 {
910 if( 1 < nFndPos )
911 {
912 pNew = new _DB_Column( rTxt.Copy( nSttPos, nFndPos -1 ) );
913 rColArr.Insert( pNew, rColArr.Count() );
914 }
915 pNew = new _DB_Column;
916 rColArr.Insert( pNew, rColArr.Count() );
917 nSttPos = nFndPos + 1;
918 }
919 if( nSttPos < rTxt.Len() )
920 {
921 pNew = new _DB_Column( rTxt.Copy( nSttPos ) );
922 rColArr.Insert( pNew, rColArr.Count() );
923 }
924 }
925 /* ---------------------------------------------------------------------------
926
927 ---------------------------------------------------------------------------*/
SplitTextToColArr(const String & rTxt,_DB_Columns & rColArr,sal_Bool bInsField)928 sal_Bool SwInsertDBColAutoPilot::SplitTextToColArr( const String& rTxt,
929 _DB_Columns& rColArr,
930 sal_Bool bInsField )
931 {
932 // aus dem Text wieder die einzelnen Datenbank - Spalten erzeugen
933 // und dann in einem Array speichern
934 // Die Datenbankspalten stehen in <> und muessen im Array der Spalten
935 // vorhanden sein:
936 String sTxt( rTxt );
937 sal_uInt16 nFndPos, nEndPos, nSttPos = 0;
938
939 while( STRING_NOTFOUND != ( nFndPos = sTxt.Search( cDBFldStart, nSttPos )))
940 {
941 nSttPos = nFndPos + 1;
942 if( STRING_NOTFOUND != ( nEndPos = sTxt.Search( cDBFldEnd, nSttPos+1 )))
943 {
944 // Text in <> geklammert gefunden: was ist es denn:
945 SwInsDBColumn aSrch( sTxt.Copy( nSttPos, nEndPos - nSttPos ), 0);
946 if( aDBColumns.Seek_Entry( &aSrch, &nFndPos ) )
947 {
948 // das ist ein gueltiges Feld
949 // also sicher den Text "davor":
950 const SwInsDBColumn& rFndCol = *aDBColumns[ nFndPos ];
951
952 _DB_Column* pNew;
953
954 if( 1 < nSttPos )
955 {
956 ::lcl_InsTextInArr( sTxt.Copy( 0, nSttPos-1 ), rColArr );
957 sTxt.Erase( 0, nSttPos-1 );
958 }
959
960 sTxt.Erase( 0, (xub_StrLen)(rFndCol.sColumn.getLength() + 2) );
961 nSttPos = 0;
962
963 sal_uInt16 nSubType = 0;
964 sal_uLong nFormat;
965 if( rFndCol.bHasFmt )
966 {
967 if( rFndCol.bIsDBFmt )
968 nFormat = rFndCol.nDBNumFmt;
969 else
970 {
971 nFormat = rFndCol.nUsrNumFmt;
972 nSubType = nsSwExtendedSubType::SUB_OWN_FMT;
973 }
974 }
975 else
976 nFormat = 0;
977
978 if( bInsField )
979 {
980 SwWrtShell& rSh = pView->GetWrtShell();
981 SwDBFieldType aFldType( rSh.GetDoc(), aSrch.sColumn,
982 aDBData );
983 pNew = new _DB_Column( rFndCol, *new SwDBField(
984 (SwDBFieldType*)rSh.InsertFldType( aFldType ),
985 nFormat ) );
986 if( nSubType )
987 pNew->DB_ColumnData.pField->SetSubType( nSubType );
988 }
989 else
990 pNew = new _DB_Column( rFndCol, nFormat );
991
992 rColArr.Insert( pNew, rColArr.Count() );
993 }
994 }
995 }
996
997 // den letzten Text nicht vergessen
998 if( sTxt.Len() )
999 ::lcl_InsTextInArr( sTxt, rColArr );
1000
1001 return 0 != rColArr.Count();
1002 }
1003 /* ---------------------------------------------------------------------------
1004
1005 ---------------------------------------------------------------------------*/
DataToDoc(const Sequence<Any> & rSelection,Reference<XDataSource> xSource,Reference<XConnection> xConnection,Reference<sdbc::XResultSet> xResultSet)1006 void SwInsertDBColAutoPilot::DataToDoc( const Sequence<Any>& rSelection,
1007 Reference< XDataSource> xSource,
1008 Reference< XConnection> xConnection,
1009 Reference< sdbc::XResultSet > xResultSet )
1010 {
1011 const Any* pSelection = rSelection.getLength() ? rSelection.getConstArray() : 0;
1012 SwWrtShell& rSh = pView->GetWrtShell();
1013
1014 //with the drag and drop interface no result set is initially available
1015 sal_Bool bDisposeResultSet = sal_False;
1016 // we don't have a cursor, so we have to create our own RowSet
1017 if ( !xResultSet.is() )
1018 {
1019 xResultSet = SwNewDBMgr::createCursor(aDBData.sDataSource,aDBData.sCommand,aDBData.nCommandType,xConnection);
1020 bDisposeResultSet = xResultSet.is();
1021 }
1022
1023 Reference< sdbc::XRow > xRow(xResultSet, UNO_QUERY);
1024 if ( !xRow.is() )
1025 return;
1026
1027 rSh.StartAllAction();
1028 sal_Bool bUndo = rSh.DoesUndo();
1029 if( bUndo )
1030 rSh.StartUndo( UNDO_EMPTY );
1031
1032 sal_Bool bAsTable = aRbAsTable.IsChecked();
1033 SvNumberFormatter& rNumFmtr = *rSh.GetNumberFormatter();
1034
1035 if( rSh.HasSelection() )
1036 rSh.DelRight();
1037
1038 ::std::auto_ptr<SwWait> pWait;
1039
1040 Reference< XColumnsSupplier > xColsSupp( xResultSet, UNO_QUERY );
1041 Reference <XNameAccess> xCols = xColsSupp->getColumns();
1042
1043 do{ // middle checked loop!!
1044 if( bAsTable ) // Daten als Tabelle einfuegen
1045 {
1046 rSh.DoUndo( sal_False );
1047
1048 sal_uInt16 n, nRows = 0, nCols = aLbTableCol.GetEntryCount();
1049 if( aCbTableHeadon.IsChecked() )
1050 nRows++;
1051
1052 if( pSelection )
1053 nRows = nRows + (sal_uInt16)rSelection.getLength();
1054 else
1055 ++nRows;
1056
1057 // bereite das Array fuer die ausgewaehlten Spalten auf
1058 SwInsDBColumns_SAR aColFlds( 255 >= nCols ? (sal_uInt8)nCols : 255, 5 );
1059 for( n = 0; n < nCols; ++n )
1060 {
1061 sal_uInt16 nFndPos;
1062 SwInsDBColumn aSrch( aLbTableCol.GetEntry( n ), 0 );
1063 if( aDBColumns.Seek_Entry( &aSrch, &nFndPos ) )
1064 aColFlds.Insert( aDBColumns[ nFndPos ], n );
1065 else {
1066 ASSERT( !this, "Datenbankspalte nicht mehr gefunden" );
1067 }
1068 }
1069
1070 if( nCols != aColFlds.Count() )
1071 {
1072 ASSERT( !this, "nicht alle Datenbankspalten gefunden" );
1073 nCols = aColFlds.Count();
1074 }
1075
1076 if(!nRows || !nCols)
1077 {
1078 ASSERT( !this, "wrong parameters" );
1079 break;
1080 }
1081
1082 const SwModuleOptions* pModOpt = SW_MOD()->GetModuleConfig();
1083
1084 sal_Bool bHTML = 0 != (::GetHtmlMode( pView->GetDocShell() ) & HTMLMODE_ON);
1085 rSh.InsertTable(
1086 pModOpt->GetInsTblFlags(bHTML),
1087 nRows, nCols, text::HoriOrientation::FULL, (pSelection ? pTAutoFmt : 0) );
1088 rSh.MoveTable( GetfnTablePrev(), GetfnTableStart() );
1089
1090 if( pSelection && pTblSet )
1091 SetTabSet();
1092
1093 SfxItemSet aTblSet( rSh.GetAttrPool(), RES_BOXATR_FORMAT,
1094 RES_BOXATR_VALUE );
1095 sal_Bool bIsAutoUpdateCells = rSh.IsAutoUpdateCells();
1096 rSh.SetAutoUpdateCells( sal_False );
1097
1098
1099 if( aCbTableHeadon.IsChecked() )
1100 {
1101 for( n = 0; n < nCols; ++n )
1102 {
1103 if( aRbHeadlColnms.IsChecked() )
1104 {
1105 rSh.SwEditShell::Insert2( aColFlds[ n ]->sColumn );
1106 }
1107 rSh.GoNextCell();
1108 }
1109 }
1110 else
1111 rSh.SetRowsToRepeat( 0 );
1112
1113 for( sal_Int32 i = 0 ; ; ++i )
1114 {
1115 sal_Bool bBreak = sal_False;
1116 try
1117 {
1118 if(pSelection)
1119 {
1120 sal_Int32 nPos = 0;
1121 pSelection[i] >>= nPos;
1122 bBreak = !xResultSet->absolute(nPos);
1123 }
1124 else if(!i)
1125 bBreak = !xResultSet->first();
1126 }
1127 catch(const Exception& )
1128 {
1129 bBreak = sal_True;
1130 }
1131 if(bBreak)
1132 break;
1133
1134 for( n = 0; n < nCols; ++n )
1135 {
1136 // beim aller erstenmal KEIN GoNextCell, weil wir schon
1137 // drin stehen. Auch nicht nach dem Insert das GoNextCell,
1138 // weil am Ende eine leere Zeile einfuegt wird.
1139 if( i || n )
1140 rSh.GoNextCell();
1141
1142 const SwInsDBColumn* pEntry = aColFlds[ n ];
1143
1144 Reference< XColumn > xColumn;
1145 xCols->getByName(pEntry->sColumn) >>= xColumn;
1146 Reference< XPropertySet > xColumnProps( xColumn, UNO_QUERY );
1147 sal_Int32 eDataType = 0;
1148 if( xColumnProps.is() )
1149 {
1150 Any aType = xColumnProps->getPropertyValue(C2U("Type"));
1151 aType >>= eDataType;
1152 }
1153 try
1154 {
1155 if( pEntry->bHasFmt )
1156 {
1157 SwTblBoxNumFormat aNumFmt(
1158 pEntry->bIsDBFmt ? pEntry->nDBNumFmt
1159 : pEntry->nUsrNumFmt );
1160 aTblSet.Put(aNumFmt);
1161 if( xColumn.is() )
1162 {
1163 double fVal = xColumn->getDouble();
1164 if( xColumn->wasNull() )
1165 aTblSet.ClearItem( RES_BOXATR_VALUE );
1166 else
1167 {
1168 if(rNumFmtr.GetType(aNumFmt.GetValue()) & NUMBERFORMAT_DATE)
1169 {
1170 ::Date aStandard(1,1,1900);
1171 if (*rNumFmtr.GetNullDate() != aStandard)
1172 fVal += (aStandard - *rNumFmtr.GetNullDate());
1173 }
1174 aTblSet.Put( SwTblBoxValue( fVal ));
1175 }
1176 }
1177 else
1178 aTblSet.ClearItem( RES_BOXATR_VALUE );
1179 rSh.SetTblBoxFormulaAttrs( aTblSet );
1180 }
1181 //#i60207# don't insert binary data as string - creates a loop
1182 else if( DataType::BINARY == eDataType ||
1183 DataType::VARBINARY == eDataType ||
1184 DataType::LONGVARBINARY== eDataType ||
1185 DataType::SQLNULL == eDataType ||
1186 DataType::OTHER == eDataType ||
1187 DataType::OBJECT == eDataType ||
1188 DataType::DISTINCT == eDataType ||
1189 DataType::STRUCT == eDataType ||
1190 DataType::ARRAY == eDataType ||
1191 DataType::BLOB == eDataType ||
1192 DataType::CLOB == eDataType ||
1193 DataType::REF == eDataType
1194 )
1195 {
1196 // do nothing
1197 }
1198 else
1199 {
1200 rtl::OUString sVal = xColumn->getString();
1201 if(!xColumn->wasNull())
1202 {
1203 rSh.SwEditShell::Insert2( sVal );
1204 }
1205 }
1206 }
1207 catch(Exception&
1208 #ifdef DBG_UTIL
1209 aExcept
1210 #endif
1211 )
1212 {
1213 DBG_ERROR(ByteString(String(aExcept.Message), gsl_getSystemTextEncoding()).GetBuffer());
1214 }
1215 }
1216
1217 if( !pSelection )
1218 {
1219 if ( !xResultSet->next() )
1220 break;
1221 }
1222 else if( i+1 >= rSelection.getLength() )
1223 break;
1224
1225 if( 10 == i )
1226 pWait = ::std::auto_ptr<SwWait>(new SwWait( *pView->GetDocShell(), true ));
1227 }
1228
1229 rSh.MoveTable( GetfnTableCurr(), GetfnTableStart() );
1230 if( !pSelection && ( pTblSet || pTAutoFmt ))
1231 {
1232 if( pTblSet )
1233 SetTabSet();
1234
1235 if( pTAutoFmt )
1236 rSh.SetTableAutoFmt( *pTAutoFmt );
1237 }
1238 rSh.SetAutoUpdateCells( bIsAutoUpdateCells );
1239 }
1240 else // Daten als Felder/Text einfuegen
1241 {
1242 _DB_Columns aColArr;
1243 if( SplitTextToColArr( aEdDbText.GetText(), aColArr, aRbAsField.IsChecked() ) )
1244 {
1245 // jetzt kann bei jedem Datensatz einfach ueber das Array iteriert
1246 // und die Daten eingefuegt werden
1247
1248 if( !rSh.IsSttPara() )
1249 rSh.SwEditShell::SplitNode();
1250 if( !rSh.IsEndPara() )
1251 {
1252 rSh.SwEditShell::SplitNode();
1253 rSh.SwCrsrShell::Left(1,CRSR_SKIP_CHARS);
1254 }
1255
1256 rSh.DoUndo( sal_False );
1257
1258 SwTxtFmtColl* pColl = 0;
1259 {
1260 String sTmplNm( aLbDbParaColl.GetSelectEntry() );
1261 if( sNoTmpl != sTmplNm )
1262 {
1263 pColl = rSh.FindTxtFmtCollByName( sTmplNm );
1264 if( !pColl )
1265 {
1266 sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName( sTmplNm, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL );
1267 if( USHRT_MAX != nId )
1268 pColl = rSh.GetTxtCollFromPool( nId );
1269 else
1270 pColl = rSh.MakeTxtFmtColl( sTmplNm );
1271 }
1272 rSh.SetTxtFmtColl( pColl );
1273 }
1274 }
1275
1276 // fuers Einfuegen als Felder -> nach jedem Datensatz ein
1277 // "NextField" einfuegen
1278 SwDBFormatData aDBFormatData;
1279 Reference< XMultiServiceFactory > xMgr( ::comphelper::getProcessServiceFactory() );
1280 if( xMgr.is() )
1281 {
1282 Reference<XInterface> xInstance = xMgr->createInstance( C2U( "com.sun.star.util.NumberFormatter" ));
1283 aDBFormatData.xFormatter = Reference<util::XNumberFormatter>(xInstance, UNO_QUERY) ;
1284 }
1285
1286 Reference<XPropertySet> xSourceProps(xSource, UNO_QUERY);
1287 if(xSourceProps.is())
1288 {
1289 Any aFormats = xSourceProps->getPropertyValue(C2U("NumberFormatsSupplier"));
1290 if(aFormats.hasValue())
1291 {
1292 Reference< util::XNumberFormatsSupplier> xSuppl;
1293 aFormats >>= xSuppl;
1294 if(xSuppl.is())
1295 {
1296 Reference< XPropertySet > xSettings = xSuppl->getNumberFormatSettings();
1297 Any aNull = xSettings->getPropertyValue(C2U("NullDate"));
1298 aNull >>= aDBFormatData.aNullDate;
1299 if(aDBFormatData.xFormatter.is())
1300 aDBFormatData.xFormatter->attachNumberFormatsSupplier(xSuppl);
1301 }
1302 }
1303 }
1304 aDBFormatData.aLocale = SvxCreateLocale( rSh.GetCurLang() );
1305 SwDBNextSetField aNxtDBFld( (SwDBNextSetFieldType*)rSh.
1306 GetFldType( 0, RES_DBNEXTSETFLD ),
1307 C2S("1"), aEmptyStr, aDBData );
1308
1309
1310 sal_Bool bSetCrsr = sal_True;
1311 sal_uInt16 n = 0, nCols = aColArr.Count();
1312 ::sw::mark::IMark* pMark = NULL;
1313 for( sal_Int32 i = 0 ; ; ++i )
1314 {
1315 sal_Bool bBreak = sal_False;
1316 try
1317 {
1318 if(pSelection)
1319 {
1320 sal_Int32 nPos = 0;
1321 pSelection[i] >>= nPos;
1322 bBreak = !xResultSet->absolute(nPos);
1323 }
1324 else if(!i)
1325 bBreak = !xResultSet->first();
1326 }
1327 catch(Exception&)
1328 {
1329 bBreak = sal_True;
1330 }
1331
1332 if(bBreak)
1333 break;
1334
1335
1336 for( n = 0; n < nCols; ++n )
1337 {
1338 _DB_Column* pDBCol = aColArr[ n ];
1339 String sIns;
1340 switch( pDBCol->eColType )
1341 {
1342 case _DB_Column::DB_FILLTEXT:
1343 sIns = *pDBCol->DB_ColumnData.pText;
1344 break;
1345
1346 case _DB_Column::DB_SPLITPARA:
1347 rSh.SplitNode();
1348 // wenn nicht die gleiche Vorlage die Follow Vorlage
1349 // ist, dann muss die ausgewaehlte neu gesetzt werden
1350 if( pColl && &pColl->GetNextTxtFmtColl() != pColl )
1351 rSh.SetTxtFmtColl( pColl );
1352 break;
1353
1354 case _DB_Column::DB_COL_FIELD:
1355 {
1356 SwDBField *const pFld = static_cast<SwDBField *>(
1357 pDBCol->DB_ColumnData.pField->CopyField());
1358 double nValue = DBL_MAX;
1359
1360 Reference< XPropertySet > xColumnProps;
1361 xCols->getByName(pDBCol->pColInfo->sColumn) >>= xColumnProps;
1362
1363 pFld->SetExpansion( SwNewDBMgr::GetDBField(
1364 xColumnProps,
1365 aDBFormatData,
1366 &nValue ) );
1367 if( DBL_MAX != nValue )
1368 {
1369 Any aType = xColumnProps->getPropertyValue(C2U("Type"));
1370 sal_Int32 eDataType = 0;
1371 aType >>= eDataType;
1372 if( DataType::DATE == eDataType || DataType::TIME == eDataType ||
1373 DataType::TIMESTAMP == eDataType)
1374
1375 {
1376 ::Date aStandard(1,1,1900);
1377 ::Date aCompare(aDBFormatData.aNullDate.Day ,
1378 aDBFormatData.aNullDate.Month,
1379 aDBFormatData.aNullDate.Year);
1380 if(aStandard != aCompare)
1381 nValue += (aStandard - aCompare);
1382 }
1383 pFld->ChgValue( nValue, sal_True );
1384 }
1385 pFld->SetInitialized();
1386
1387 rSh.Insert( *pFld );
1388 delete pFld;
1389 }
1390 break;
1391
1392 case _DB_Column::DB_COL_TEXT:
1393 {
1394 double nValue = DBL_MAX;
1395 Reference< XPropertySet > xColumnProps;
1396 xCols->getByName(pDBCol->pColInfo->sColumn) >>= xColumnProps;
1397 sIns = SwNewDBMgr::GetDBField(
1398 xColumnProps,
1399 aDBFormatData,
1400 &nValue );
1401 if( pDBCol->DB_ColumnData.nFormat &&
1402 DBL_MAX != nValue )
1403 {
1404 Color* pCol;
1405 if(rNumFmtr.GetType(pDBCol->DB_ColumnData.nFormat) & NUMBERFORMAT_DATE)
1406 {
1407 ::Date aStandard(1,1,1900);
1408 if (*rNumFmtr.GetNullDate() != aStandard)
1409 nValue += (aStandard - *rNumFmtr.GetNullDate());
1410 }
1411 rNumFmtr.GetOutputString( nValue,
1412 pDBCol->DB_ColumnData.nFormat,
1413 sIns, &pCol );
1414 }
1415 }
1416 break;
1417 }
1418
1419 if( sIns.Len() )
1420 rSh.Insert( sIns );
1421
1422 if( bSetCrsr && sIns.Len() )
1423 {
1424 // zum Anfang und eine Mark setzen, damit der
1425 // Cursor am Ende wieder auf Anfangsposition
1426 // gesetzt werden kann.
1427
1428 // rSh.SwCrsrShell::MovePara( fnParaCurr, fnParaStart );
1429 rSh.SwCrsrShell::MovePara(
1430 GetfnParaCurr(), GetfnParaStart() );
1431 pMark = rSh.SetBookmark(
1432 KeyCode(),
1433 ::rtl::OUString(),
1434 ::rtl::OUString(), IDocumentMarkAccess::UNO_BOOKMARK );
1435 // rSh.SwCrsrShell::MovePara( fnParaCurr, fnParaEnd );
1436 rSh.SwCrsrShell::MovePara(
1437 GetfnParaCurr(), GetfnParaEnd() );
1438 bSetCrsr = sal_False;
1439 }
1440 }
1441
1442 if( !pSelection )
1443 {
1444 sal_Bool bNext = xResultSet->next();
1445 if(!bNext)
1446 break;
1447 }
1448 else if( i+1 >= rSelection.getLength() )
1449 break;
1450
1451 if( aRbAsField.IsChecked() )
1452 rSh.Insert( aNxtDBFld );
1453
1454 if( !rSh.IsSttPara() )
1455 rSh.SwEditShell::SplitNode();
1456
1457 if( 10 == i )
1458 pWait = ::std::auto_ptr<SwWait>(new SwWait( *pView->GetDocShell(), true ));
1459 }
1460
1461 if( !bSetCrsr && pMark != NULL)
1462 {
1463 rSh.SetMark();
1464 rSh.GotoMark( pMark );
1465 rSh.getIDocumentMarkAccess()->deleteMark( pMark );
1466 break;
1467 }
1468 }
1469 }
1470 // write configuration
1471 Commit();
1472 }while( sal_False ); // middle checked loop
1473
1474 if( bUndo )
1475 {
1476 rSh.DoUndo( sal_True );
1477 rSh.AppendUndoForInsertFromDB( bAsTable );
1478 rSh.EndUndo( UNDO_EMPTY );
1479 }
1480 rSh.ClearMark();
1481 rSh.EndAllAction();
1482
1483 if ( bDisposeResultSet )
1484 ::comphelper::disposeComponent(xResultSet);
1485 }
SetTabSet()1486 void SwInsertDBColAutoPilot::SetTabSet()
1487 {
1488 SwWrtShell& rSh = pView->GetWrtShell();
1489 const SfxPoolItem* pItem;
1490
1491 if( pTAutoFmt )
1492 {
1493 if( pTAutoFmt->IsFrame() )
1494 {
1495 // Umrandung kommt vom AutoFormat
1496 pTblSet->ClearItem( RES_BOX );
1497 pTblSet->ClearItem( SID_ATTR_BORDER_INNER );
1498 }
1499 if( pTAutoFmt->IsBackground() )
1500 {
1501 pTblSet->ClearItem( RES_BACKGROUND );
1502 pTblSet->ClearItem( SID_ATTR_BRUSH_ROW );
1503 pTblSet->ClearItem( SID_ATTR_BRUSH_TABLE );
1504 }
1505 }
1506 else
1507 {
1508 // die Defaults wieder entfernen, es macht keinen Sinn sie zu setzen
1509 SvxBrushItem aBrush( RES_BACKGROUND );
1510 static sal_uInt16 __READONLY_DATA aIds[3] =
1511 { RES_BACKGROUND, SID_ATTR_BRUSH_ROW, SID_ATTR_BRUSH_TABLE };
1512 for( int i = 0; i < 3; ++i )
1513 if( SFX_ITEM_SET == pTblSet->GetItemState( aIds[ i ],
1514 sal_False, &pItem ) && *pItem == aBrush )
1515 pTblSet->ClearItem( aIds[ i ] );
1516 }
1517
1518 if( SFX_ITEM_SET == pTblSet->GetItemState( FN_PARAM_TABLE_NAME, sal_False,
1519 &pItem ) && ((const SfxStringItem*)pItem)->GetValue() ==
1520 rSh.GetTableFmt()->GetName() )
1521 pTblSet->ClearItem( FN_PARAM_TABLE_NAME );
1522
1523 rSh.MoveTable( GetfnTableCurr(), GetfnTableStart() );
1524 rSh.SetMark();
1525 rSh.MoveTable( GetfnTableCurr(), GetfnTableEnd() );
1526
1527 ItemSetToTableParam( *pTblSet, rSh );
1528
1529 rSh.ClearMark();
1530 rSh.MoveTable( GetfnTableCurr(), GetfnTableStart() );
1531 }
1532
1533 /* */
1534
1535
~_DB_ColumnConfigData()1536 _DB_ColumnConfigData::~_DB_ColumnConfigData() {}
1537
1538 /* -----------------------------05.12.00 16:15--------------------------------
1539
1540 ---------------------------------------------------------------------------*/
lcl_createSourceNames(const String & rNodeName)1541 static Sequence<rtl::OUString> lcl_createSourceNames(const String& rNodeName)
1542 {
1543 Sequence<rtl::OUString> aSourceNames(11);
1544 rtl::OUString* pNames = aSourceNames.getArray();
1545
1546 String sTmp( rNodeName );
1547 const xub_StrLen nPos = sTmp.Len();
1548 pNames[0] = sTmp.ReplaceAscii( nPos, STRING_MAXLEN,
1549 RTL_CONSTASCII_STRINGPARAM( "/DataSource" ));
1550 pNames[1] = sTmp.ReplaceAscii( nPos, STRING_MAXLEN,
1551 RTL_CONSTASCII_STRINGPARAM( "/Command" ));
1552 pNames[2] = sTmp.ReplaceAscii( nPos, STRING_MAXLEN,
1553 RTL_CONSTASCII_STRINGPARAM( "/CommandType" ));
1554 pNames[3] = sTmp.ReplaceAscii( nPos, STRING_MAXLEN,
1555 RTL_CONSTASCII_STRINGPARAM( "/ColumnsToText" ));
1556 pNames[4] = sTmp.ReplaceAscii( nPos, STRING_MAXLEN,
1557 RTL_CONSTASCII_STRINGPARAM( "/ColumnsToTable" ));
1558 pNames[5] = sTmp.ReplaceAscii( nPos, STRING_MAXLEN,
1559 RTL_CONSTASCII_STRINGPARAM( "/ParaStyle" ));
1560 pNames[6] = sTmp.ReplaceAscii( nPos, STRING_MAXLEN,
1561 RTL_CONSTASCII_STRINGPARAM( "/TableAutoFormat" ));
1562 pNames[7] = sTmp.ReplaceAscii( nPos, STRING_MAXLEN,
1563 RTL_CONSTASCII_STRINGPARAM( "/IsTable" ));
1564 pNames[8] = sTmp.ReplaceAscii( nPos, STRING_MAXLEN,
1565 RTL_CONSTASCII_STRINGPARAM( "/IsField" ));
1566 pNames[9] = sTmp.ReplaceAscii( nPos, STRING_MAXLEN,
1567 RTL_CONSTASCII_STRINGPARAM( "/IsHeadlineOn" ));
1568 pNames[10] = sTmp.ReplaceAscii( nPos, STRING_MAXLEN,
1569 RTL_CONSTASCII_STRINGPARAM( "/IsEmptyHeadline" ));
1570 return aSourceNames;
1571 }
1572 /* -----------------------------05.12.00 16:25--------------------------------
1573
1574 ---------------------------------------------------------------------------*/
lcl_CreateSubNames(const String & rSubNodeName)1575 static Sequence<rtl::OUString> lcl_CreateSubNames( const String& rSubNodeName )
1576 {
1577 Sequence<rtl::OUString> aSubSourceNames(6);
1578 rtl::OUString* pNames = aSubSourceNames.getArray();
1579 String sTmp( rSubNodeName );
1580 const xub_StrLen nPos = sTmp.Len();
1581 pNames[0] = sTmp.ReplaceAscii( nPos, STRING_MAXLEN,
1582 RTL_CONSTASCII_STRINGPARAM( "/ColumnName" ));
1583 pNames[1] = sTmp.ReplaceAscii( nPos, STRING_MAXLEN,
1584 RTL_CONSTASCII_STRINGPARAM( "/ColumnIndex" ));
1585 pNames[2] = sTmp.ReplaceAscii( nPos, STRING_MAXLEN,
1586 RTL_CONSTASCII_STRINGPARAM( "/IsNumberFormat" ));
1587 pNames[3] = sTmp.ReplaceAscii( nPos, STRING_MAXLEN,
1588 RTL_CONSTASCII_STRINGPARAM( "/IsNumberFormatFromDataBase" ));
1589 pNames[4] = sTmp.ReplaceAscii( nPos, STRING_MAXLEN,
1590 RTL_CONSTASCII_STRINGPARAM( "/NumberFormat" ));
1591 pNames[5] = sTmp.ReplaceAscii( nPos, STRING_MAXLEN,
1592 RTL_CONSTASCII_STRINGPARAM( "/NumberFormatLocale" ));
1593 return aSubSourceNames;
1594 }
1595 /* -----------------------------06.12.00 13:03--------------------------------
1596
1597 ---------------------------------------------------------------------------*/
lcl_CreateUniqueName(const Sequence<rtl::OUString> & aNames)1598 static rtl::OUString lcl_CreateUniqueName(const Sequence<rtl::OUString>& aNames)
1599 {
1600 sal_Int32 nIdx = aNames.getLength();
1601 const rtl::OUString* pNames = aNames.getConstArray();
1602 rtl::OUString sTest(C2U("_"));
1603 rtl::OUString sRet;
1604 while(sal_True)
1605 {
1606 sRet = sTest; sRet += rtl::OUString::valueOf(nIdx++);
1607 sal_Bool bFound = sal_False;
1608 for(sal_Int32 i = 0; i < aNames.getLength(); i++)
1609 {
1610 if(pNames[i] == sRet)
1611 {
1612 bFound = sal_True;
1613 break;
1614 }
1615 }
1616 if(!bFound)
1617 break;
1618 }
1619 return sRet;
1620 }
1621 /* -----------------------------05.12.00 15:00--------------------------------
1622
1623 ---------------------------------------------------------------------------*/
Notify(const::com::sun::star::uno::Sequence<rtl::OUString> &)1624 void SwInsertDBColAutoPilot::Notify( const ::com::sun::star::uno::Sequence< rtl::OUString >& ) {}
1625
Commit()1626 void SwInsertDBColAutoPilot::Commit()
1627 {
1628 Sequence <rtl::OUString> aNames = GetNodeNames(rtl::OUString());
1629 const rtl::OUString* pNames = aNames.getArray();
1630 //remove entries that contain this data source + table at first
1631 for(sal_Int32 nNode = 0; nNode < aNames.getLength(); nNode++)
1632 {
1633 Sequence<rtl::OUString> aSourceNames(2);
1634 rtl::OUString* pSourceNames = aSourceNames.getArray();
1635 pSourceNames[0] = pNames[nNode];
1636 pSourceNames[0] += C2U("/DataSource");
1637 pSourceNames[1] = pNames[nNode];
1638 pSourceNames[1] += C2U("/Command");
1639 Sequence<Any> aSourceProperties = GetProperties(aSourceNames);
1640 const Any* pSourceProps = aSourceProperties.getArray();
1641 rtl::OUString sSource, sCommand;
1642 pSourceProps[0] >>= sSource;
1643 pSourceProps[1] >>= sCommand;
1644 if(sSource.equals(aDBData.sDataSource) && sCommand.equals(aDBData.sCommand))
1645 {
1646 Sequence<rtl::OUString> aElements(1);
1647 aElements.getArray()[0] = pNames[nNode];
1648 ClearNodeElements(rtl::OUString(), aElements);
1649 }
1650 }
1651
1652 aNames = GetNodeNames(rtl::OUString());
1653 rtl::OUString sNewNode = lcl_CreateUniqueName(aNames);
1654 Sequence<rtl::OUString> aNodeNames = lcl_createSourceNames(sNewNode);
1655 Sequence<PropertyValue> aValues(aNodeNames.getLength());
1656 PropertyValue* pValues = aValues.getArray();
1657 const rtl::OUString* pNodeNames = aNodeNames.getConstArray();
1658 rtl::OUString sSlash(C2U("/"));
1659 for(sal_Int32 i = 0; i < aNodeNames.getLength(); i++)
1660 {
1661 pValues[i].Name = sSlash;
1662 pValues[i].Name += pNodeNames[i];
1663 }
1664
1665 pValues[0].Value <<= rtl::OUString(aDBData.sDataSource);
1666 pValues[1].Value <<= rtl::OUString(aDBData.sCommand);
1667 pValues[2].Value <<= aDBData.nCommandType;
1668 pValues[3].Value <<= rtl::OUString(aEdDbText.GetText());
1669
1670 String sTmp;
1671 for( sal_uInt16 n = 0, nCnt = aLbTableCol.GetEntryCount(); n < nCnt; ++n )
1672 ( sTmp += aLbTableCol.GetEntry( n ) ) += '\x0a';
1673
1674 if( sTmp.Len() )
1675 pValues[4].Value <<= rtl::OUString(sTmp);
1676
1677 if( sNoTmpl != (sTmp = aLbDbParaColl.GetSelectEntry()) )
1678 pValues[5].Value <<= rtl::OUString(sTmp);
1679
1680 if( pTAutoFmt )
1681 pValues[6].Value <<= rtl::OUString(pTAutoFmt->GetName());
1682
1683 const Type& rBoolType = ::getBooleanCppuType();
1684 sal_Bool bTmp = aRbAsTable.IsChecked();
1685 pValues[7].Value.setValue(&bTmp, rBoolType);
1686
1687 bTmp = aRbAsField.IsChecked();
1688 pValues[8].Value.setValue(&bTmp, rBoolType);
1689
1690 bTmp = aCbTableHeadon.IsChecked();
1691 pValues[9].Value.setValue(&bTmp, rBoolType);
1692
1693 bTmp = aRbHeadlEmpty.IsChecked();
1694 pValues[10].Value.setValue(&bTmp, rBoolType);
1695
1696 SetSetProperties(rtl::OUString(), aValues);
1697
1698 sNewNode += C2U("/ColumnSet");
1699 String sDelim( String::CreateFromAscii( "/__" ));
1700
1701 LanguageType ePrevLang = (LanguageType)-1;
1702 rtl::OUString sPrevLang;
1703
1704 SvNumberFormatter& rNFmtr = *pView->GetWrtShell().GetNumberFormatter();
1705 for(sal_uInt16 nCol = 0; nCol < aDBColumns.Count(); nCol++)
1706 {
1707 rtl::OUString sColumnNode = sNewNode;
1708 SwInsDBColumn* pColumn = aDBColumns[nCol];
1709 String sColumnInsertNode(sColumnNode);
1710 sColumnInsertNode += sDelim;
1711 if( nCol < 100 )
1712 sColumnInsertNode += '0';
1713 if( nCol < 10 )
1714 sColumnInsertNode += '0';
1715 sColumnInsertNode += String::CreateFromInt32( nCol );
1716
1717 Sequence <rtl::OUString> aSubNodeNames = lcl_CreateSubNames(sColumnInsertNode);
1718 Sequence<PropertyValue> aSubValues(aSubNodeNames.getLength());
1719 PropertyValue* pSubValues = aSubValues.getArray();
1720 const rtl::OUString* pSubNodeNames = aSubNodeNames.getConstArray();
1721 sal_Int32 i;
1722
1723 for( i = 0; i < aSubNodeNames.getLength(); i++)
1724 pSubValues[i].Name = pSubNodeNames[i];
1725 pSubValues[0].Value <<= pColumn->sColumn;
1726 pSubValues[1].Value <<= i;
1727
1728 sal_Bool bVal = pColumn->bHasFmt;
1729 pSubValues[2].Value.setValue(&bVal, rBoolType);
1730 bVal = pColumn->bIsDBFmt;
1731 pSubValues[3].Value.setValue(&bVal, rBoolType);
1732
1733 SwStyleNameMapper::FillUIName( RES_POOLCOLL_STANDARD, sTmp );
1734 const SvNumberformat* pNF = rNFmtr.GetEntry( pColumn->nUsrNumFmt );
1735 LanguageType eLang;
1736 if( pNF )
1737 {
1738 pSubValues[4].Value <<= rtl::OUString(pNF->GetFormatstring());
1739 eLang = pNF->GetLanguage();
1740 }
1741 else
1742 {
1743 pSubValues[4].Value <<= rtl::OUString(sTmp);
1744 eLang = (LanguageType)GetAppLanguage();
1745 }
1746
1747 if( eLang != ePrevLang )
1748 {
1749 Locale aLocale;
1750 aLocale = SvxLanguageToLocale( aLocale, eLang );
1751 (( sPrevLang = aLocale.Country ) += rtl::OUString( '-' )) += aLocale.Language;
1752 ePrevLang = eLang;
1753 }
1754
1755 pSubValues[5].Value <<= sPrevLang;
1756 SetSetProperties(sColumnNode, aSubValues);
1757 }
1758 }
1759 /* -----------------------------05.12.00 15:00--------------------------------
1760
1761 ---------------------------------------------------------------------------*/
Load()1762 void SwInsertDBColAutoPilot::Load()
1763 {
1764 Sequence <rtl::OUString> aNames = GetNodeNames(rtl::OUString());
1765 const rtl::OUString* pNames = aNames.getArray();
1766 SvNumberFormatter& rNFmtr = *pView->GetWrtShell().GetNumberFormatter();
1767 for(sal_Int32 nNode = 0; nNode < aNames.getLength(); nNode++)
1768 {
1769 //search for entries with the appropriate data source and table
1770 Sequence<rtl::OUString> aSourceNames = lcl_createSourceNames(pNames[nNode]);
1771
1772 Sequence< Any> aDataSourceProps = GetProperties(aSourceNames);
1773 const Any* pDataSourceProps = aDataSourceProps.getConstArray();
1774 rtl::OUString sSource, sCommand;
1775 sal_Int16 nCommandType;
1776 pDataSourceProps[0] >>= sSource;
1777 pDataSourceProps[1] >>= sCommand;
1778 pDataSourceProps[2] >>= nCommandType;
1779 if(sSource.equals(aDBData.sDataSource) && sCommand.equals(aDBData.sCommand))
1780 {
1781 _DB_ColumnConfigData* pNewData = new _DB_ColumnConfigData;
1782 pNewData->sSource = sSource;
1783 pNewData->sTable = sCommand;
1784
1785 pDataSourceProps[3] >>= pNewData->sEdit;
1786 pDataSourceProps[4] >>= pNewData->sTblList;
1787 pDataSourceProps[5] >>= pNewData->sTmplNm;
1788 pDataSourceProps[6] >>= pNewData->sTAutoFmtNm;
1789 if(pDataSourceProps[7].hasValue())
1790 pNewData->bIsTable = *(sal_Bool*)pDataSourceProps[7].getValue();
1791 if(pDataSourceProps[8].hasValue())
1792 pNewData->bIsField = *(sal_Bool*)pDataSourceProps[8].getValue();
1793 if(pDataSourceProps[9].hasValue())
1794 pNewData->bIsHeadlineOn = *(sal_Bool*)pDataSourceProps[9].getValue();
1795 if(pDataSourceProps[10].hasValue())
1796 pNewData->bIsEmptyHeadln = *(sal_Bool*)pDataSourceProps[10].getValue();
1797
1798 rtl::OUString sSubNodeName(pNames[nNode]);
1799 sSubNodeName += C2U("/ColumnSet/");
1800 Sequence <rtl::OUString> aSubNames = GetNodeNames(sSubNodeName);
1801 const rtl::OUString* pSubNames = aSubNames.getConstArray();
1802 for(sal_Int32 nSub = 0; nSub < aSubNames.getLength(); nSub++)
1803 {
1804 rtl::OUString sSubSubNodeName(sSubNodeName);
1805 sSubSubNodeName += pSubNames[nSub];
1806 Sequence <rtl::OUString> aSubNodeNames = lcl_CreateSubNames(sSubSubNodeName);
1807 Sequence< Any> aSubProps = GetProperties(aSubNodeNames);
1808 const Any* pSubProps = aSubProps.getConstArray();
1809
1810 rtl::OUString sColumn;
1811 pSubProps[0] >>= sColumn;
1812 //check for existance of the loaded column name
1813 sal_Bool bFound = sal_False;
1814 for(sal_Int32 nRealColumn = 0; nRealColumn < aDBColumns.Count(); nRealColumn++)
1815 {
1816 if(aDBColumns[(sal_uInt16)nRealColumn]->sColumn == sColumn)
1817 {
1818 bFound = sal_True;
1819 break;
1820 }
1821 }
1822 if(!bFound)
1823 continue;
1824 sal_Int16 nIndex = 0;
1825 pSubProps[1] >>= nIndex;
1826 SwInsDBColumnPtr pInsDBColumn = new SwInsDBColumn(sColumn, nIndex);
1827 if(pSubProps[2].hasValue())
1828 pInsDBColumn->bHasFmt = *(sal_Bool*)pSubProps[2].getValue();
1829 if(pSubProps[3].hasValue())
1830 pInsDBColumn->bIsDBFmt = *(sal_Bool*)pSubProps[3].getValue();
1831
1832 pSubProps[4] >>= pInsDBColumn->sUsrNumFmt;
1833 rtl::OUString sNumberFormatLocale;
1834 pSubProps[5] >>= sNumberFormatLocale;
1835
1836 Locale aLocale;
1837 aLocale.Language = sNumberFormatLocale.copy(0, 2);
1838 aLocale.Country = sNumberFormatLocale.copy(3, 2);
1839 pInsDBColumn->eUsrNumFmtLng = SvxLocaleToLanguage( aLocale );
1840
1841 pInsDBColumn->nUsrNumFmt = rNFmtr.GetEntryKey( pInsDBColumn->sUsrNumFmt,
1842 pInsDBColumn->eUsrNumFmtLng );
1843
1844 // pInsDBColumn->nDBNumFmt
1845
1846 pNewData->aDBColumns.Insert(pInsDBColumn);
1847 }
1848 sal_uInt16 n = 0;
1849 String sTmp( pNewData->sTblList );
1850 if( sTmp.Len() )
1851 {
1852 do {
1853 String sEntry( sTmp.GetToken( 0, '\x0a', n ) );
1854 //preselect column - if they still exist!
1855 if(aLbTblDbColumn.GetEntryPos(sEntry) != LISTBOX_ENTRY_NOTFOUND)
1856 {
1857 aLbTableCol.InsertEntry( sEntry );
1858 aLbTblDbColumn.RemoveEntry( sEntry );
1859 }
1860 } while( n < sTmp.Len() );
1861
1862 if( !aLbTblDbColumn.GetEntryCount() )
1863 {
1864 aIbDbcolAllTo.Enable( sal_False );
1865 aIbDbcolOneTo.Enable( sal_False );
1866 }
1867 aIbDbcolOneFrom.Enable( sal_True );
1868 aIbDbcolAllFrom.Enable( sal_True );
1869 }
1870 aEdDbText.SetText( pNewData->sEdit );
1871
1872 sTmp = pNewData->sTmplNm;
1873 if( sTmp.Len() )
1874 aLbDbParaColl.SelectEntry( sTmp );
1875 else
1876 aLbDbParaColl.SelectEntryPos( 0 );
1877
1878 if( pTAutoFmt )
1879 delete pTAutoFmt, pTAutoFmt = 0;
1880 sTmp = pNewData->sTAutoFmtNm;
1881 if( sTmp.Len() )
1882 {
1883 // dann erstmal die AutoFmt-Datei laden und das Autoformat suchen
1884 SwTableAutoFmtTbl aAutoFmtTbl;
1885 aAutoFmtTbl.Load();
1886 for( sal_uInt16 nAutoFmt = aAutoFmtTbl.Count(); nAutoFmt; )
1887 if( sTmp == aAutoFmtTbl[ --nAutoFmt ]->GetName() )
1888 {
1889 pTAutoFmt = new SwTableAutoFmt( *aAutoFmtTbl[ nAutoFmt ] );
1890 break;
1891 }
1892 }
1893
1894 aRbAsTable.Check( pNewData->bIsTable );
1895 aRbAsField.Check( pNewData->bIsField );
1896 aRbAsText.Check( !pNewData->bIsTable && !pNewData->bIsField );
1897
1898 aCbTableHeadon.Check( pNewData->bIsHeadlineOn );
1899 aRbHeadlColnms.Check( !pNewData->bIsEmptyHeadln );
1900 aRbHeadlEmpty.Check( pNewData->bIsEmptyHeadln );
1901 HeaderHdl(&aCbTableHeadon);
1902
1903 // jetzt noch die benutzerdefinierten Numberformat Strings in die
1904 // Shell kopieren. Nur diese sind dann als ID verfuegbar
1905 for( n = 0; n < aDBColumns.Count() ; ++n )
1906 {
1907 SwInsDBColumn& rSet = *aDBColumns[ n ];
1908 for( sal_uInt16 m = 0; m < pNewData->aDBColumns.Count() ; ++m )
1909 {
1910 SwInsDBColumn& rGet = *pNewData->aDBColumns[ m ];
1911 if(rGet.sColumn == rSet.sColumn)
1912 {
1913 if( rGet.bHasFmt && !rGet.bIsDBFmt )
1914 {
1915 rSet.bIsDBFmt = sal_False;
1916 rSet.nUsrNumFmt = rNFmtr.GetEntryKey( rGet.sUsrNumFmt,
1917 rGet.eUsrNumFmtLng );
1918 if( NUMBERFORMAT_ENTRY_NOT_FOUND == rSet.nUsrNumFmt )
1919 {
1920 xub_StrLen nCheckPos;
1921 short nType;
1922 String sTmpFmt = rGet.sUsrNumFmt;
1923 rNFmtr.PutEntry( sTmpFmt, nCheckPos, nType,
1924 rSet.nUsrNumFmt, rGet.eUsrNumFmtLng );
1925 rGet.sUsrNumFmt = sTmpFmt;
1926 }
1927 }
1928 break;
1929 }
1930 }
1931 }
1932
1933 // steht der Cursor in einer Tabelle, darf NIE Tabelle auswaehlbar sein
1934 if( !aRbAsTable.IsEnabled() && aRbAsTable.IsChecked() )
1935 aRbAsField.Check( sal_True );
1936 delete pNewData;
1937 break;
1938 }
1939 }
1940 }
1941
1942