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 139 _DB_Column() 140 { 141 pColInfo = 0; 142 DB_ColumnData.pText = 0; 143 eColType = DB_SPLITPARA; 144 } 145 146 _DB_Column( const String& rTxt ) 147 { 148 pColInfo = 0; 149 DB_ColumnData.pText = new String( rTxt ); 150 eColType = DB_FILLTEXT; 151 } 152 153 _DB_Column( const SwInsDBColumn& rInfo, sal_uLong nFormat ) 154 { 155 pColInfo = &rInfo; 156 DB_ColumnData.nFormat = nFormat; 157 eColType = DB_COL_TEXT; 158 } 159 160 _DB_Column( const SwInsDBColumn& rInfo, SwDBField& rFld ) 161 { 162 pColInfo = &rInfo; 163 DB_ColumnData.pField = &rFld; 164 eColType = DB_COL_FIELD; 165 } 166 167 ~_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 197 _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 211 int SwInsDBColumn::operator<( const SwInsDBColumn& rCmp ) const 212 { 213 return 0 > GetAppCollator().compareString( sColumn, rCmp.sColumn ); 214 } 215 /* --------------------------------------------------------------------------- 216 217 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 455 SwInsertDBColAutoPilot::~SwInsertDBColAutoPilot() 456 { 457 delete pTblSet; 458 delete pRep; 459 460 // delete pConfig; 461 delete pTAutoFmt; 462 } 463 /* --------------------------------------------------------------------------- 464 465 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 } 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 1536 _DB_ColumnConfigData::~_DB_ColumnConfigData() {} 1537 1538 /* -----------------------------05.12.00 16:15-------------------------------- 1539 1540 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 1624 void SwInsertDBColAutoPilot::Notify( const ::com::sun::star::uno::Sequence< rtl::OUString >& ) {} 1625 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 ---------------------------------------------------------------------------*/ 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 existence 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