1 /************************************************************************* 2 * 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * Copyright 2000, 2010 Oracle and/or its affiliates. 6 * 7 * OpenOffice.org - a multi-platform office productivity suite 8 * 9 * This file is part of OpenOffice.org. 10 * 11 * OpenOffice.org is free software: you can redistribute it and/or modify 12 * it under the terms of the GNU Lesser General Public License version 3 13 * only, as published by the Free Software Foundation. 14 * 15 * OpenOffice.org is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU Lesser General Public License version 3 for more details 19 * (a copy is included in the LICENSE file that accompanied this code). 20 * 21 * You should have received a copy of the GNU Lesser General Public License 22 * version 3 along with OpenOffice.org. If not, see 23 * <http://www.openoffice.org/license.html> 24 * for a copy of the LGPLv3 License. 25 * 26 ************************************************************************/ 27 28 // MARKER(update_precomp.py): autogen include statement, do not remove 29 #include "precompiled_dbaccess.hxx" 30 #ifndef DBAUI_TABLEEDITORCONTROL_HXX 31 #include "TEditControl.hxx" 32 #endif 33 #ifndef _TOOLS_DEBUG_HXX 34 #include <tools/debug.hxx> 35 #endif 36 #ifndef _COM_SUN_STAR_SDBC_XDATABASEMETADATA_HPP_ 37 #include <com/sun/star/sdbc/XDatabaseMetaData.hpp> 38 #endif 39 #ifndef _COM_SUN_STAR_SDBCX_XCOLUMNSSUPPLIER_HPP_ 40 #include <com/sun/star/sdbcx/XColumnsSupplier.hpp> 41 #endif 42 #ifndef _COM_SUN_STAR_SDBCX_XALTERTABLE_HPP_ 43 #include <com/sun/star/sdbcx/XAlterTable.hpp> 44 #endif 45 #ifndef _COM_SUN_STAR_SDBCX_XDROP_HPP_ 46 #include <com/sun/star/sdbcx/XDrop.hpp> 47 #endif 48 #ifndef _COM_SUN_STAR_SDBCX_XAPPEND_HPP_ 49 #include <com/sun/star/sdbcx/XAppend.hpp> 50 #endif 51 #ifndef _COM_SUN_STAR_BEANS_PROPERTYATTRIBUTE_HPP_ 52 #include <com/sun/star/beans/PropertyAttribute.hpp> 53 #endif 54 #ifndef _COM_SUN_STAR_UTIL_XNUMBERFORMATTYPES_HPP_ 55 #include <com/sun/star/util/XNumberFormatTypes.hpp> 56 #endif 57 #ifndef _DBU_TBL_HRC_ 58 #include "dbu_tbl.hrc" 59 #endif 60 #ifndef DBACCESS_SHARED_DBUSTRINGS_HRC 61 #include "dbustrings.hrc" 62 #endif 63 #ifndef DBACCESS_UI_BROWSER_ID_HXX 64 #include "browserids.hxx" 65 #endif 66 #ifndef _DBA_DBACCESS_HELPID_HRC_ 67 #include "dbaccess_helpid.hrc" 68 #endif 69 #ifndef _COMPHELPER_TYPES_HXX_ 70 #include <comphelper/types.hxx> 71 #endif 72 #ifndef DBAUI_FIELDDESCRIPTIONCONTROL_HXX 73 #include "FieldDescControl.hxx" 74 #endif 75 #ifndef DBAUI_FIELDDESCRIPTIONS_HXX 76 #include "FieldDescriptions.hxx" 77 #endif 78 #ifndef _SV_MSGBOX_HXX 79 #include <vcl/msgbox.hxx> 80 #endif 81 #ifndef DBAUI_TABLEUNDO_HXX 82 #include "TableUndo.hxx" 83 #endif 84 #ifndef DBUI_TABLECONTROLLER_HXX 85 #include "TableController.hxx" 86 #endif 87 #ifndef _CONNECTIVITY_DBTOOLS_HXX_ 88 #include <connectivity/dbtools.hxx> 89 #endif 90 #ifndef DBAUI_SQLNAMEEDIT_HXX 91 #include "SqlNameEdit.hxx" 92 #endif 93 #ifndef DBAUI_TABLEROW_EXCHANGE_HXX 94 #include "TableRowExchange.hxx" 95 #endif 96 #ifndef _SOT_STORAGE_HXX 97 #include <sot/storage.hxx> 98 #endif 99 #ifndef DBAUI_TOOLS_HXX 100 #include "UITools.hxx" 101 #endif 102 #ifndef DBAUI_FIELDDESCRIPTIONCONTROL_HXX 103 #include "FieldDescControl.hxx" 104 #endif 105 #ifndef DBAUI_TABLEFIELDCONTROL_HXX 106 #include "TableFieldControl.hxx" 107 #endif 108 #include "dsntypes.hxx" 109 110 #include "dbaccess_slotid.hrc" 111 112 using namespace ::dbaui; 113 using namespace ::comphelper; 114 using namespace ::svt; 115 using namespace ::com::sun::star::uno; 116 using namespace ::com::sun::star::container; 117 using namespace ::com::sun::star::io; 118 using namespace ::com::sun::star::beans; 119 using namespace ::com::sun::star::frame; 120 using namespace ::com::sun::star::util; 121 using namespace ::com::sun::star::lang; 122 using namespace ::com::sun::star::sdbc; 123 using namespace ::com::sun::star::sdbcx; 124 using namespace ::com::sun::star::sdb; 125 126 namespace dbaui 127 { 128 extern String GetTypeString( sal_uInt16 nType ); 129 } 130 //============================================================================== 131 132 // TYPEINIT1(OTableEditorCtrl, DBView); 133 DBG_NAME(OTableEditorCtrl) 134 135 //============================================================================== 136 137 #define HANDLE_ID 0 138 139 // default Spaltenbreiten 140 #define FIELDNAME_WIDTH 100 141 #define FIELDTYPE_WIDTH 150 142 #define FIELDDESCR_WIDTH 300 143 144 // Maximale Eingabelaenge im Beschreibungsfeld 145 #define MAX_DESCR_LEN 256 146 147 148 #define CONTROL_SPACING_X 18 // 6 149 #define CONTROL_SPACING_Y 5 150 #define CONTROL_HEIGHT 20 151 #define CONTROL_WIDTH_1 140 // 100 152 #define CONTROL_WIDTH_2 100 // 60 153 #define CONTROL_WIDTH_3 250 154 #define CONTROL_WIDTH_4 (CONTROL_WIDTH_3 - CONTROL_HEIGHT - 5) 155 156 157 //================================================================== 158 DBG_NAME(ClipboardInvalidator) 159 //------------------------------------------------------------------ 160 OTableEditorCtrl::ClipboardInvalidator::ClipboardInvalidator(sal_uLong nTimeout,OTableEditorCtrl* _pOwner) 161 : m_pOwner(_pOwner) 162 { 163 DBG_CTOR(ClipboardInvalidator,NULL); 164 165 m_aInvalidateTimer.SetTimeout(nTimeout); 166 m_aInvalidateTimer.SetTimeoutHdl(LINK(this, OTableEditorCtrl::ClipboardInvalidator, OnInvalidate)); 167 m_aInvalidateTimer.Start(); 168 } 169 170 //------------------------------------------------------------------ 171 OTableEditorCtrl::ClipboardInvalidator::~ClipboardInvalidator() 172 { 173 m_aInvalidateTimer.Stop(); 174 175 DBG_DTOR(ClipboardInvalidator,NULL); 176 } 177 178 //------------------------------------------------------------------ 179 IMPL_LINK(OTableEditorCtrl::ClipboardInvalidator, OnInvalidate, void*, EMPTYARG) 180 { 181 m_pOwner->GetView()->getController().InvalidateFeature(SID_CUT); 182 m_pOwner->GetView()->getController().InvalidateFeature(SID_COPY); 183 m_pOwner->GetView()->getController().InvalidateFeature(SID_PASTE); 184 return 0L; 185 } 186 187 //================================================================== 188 void OTableEditorCtrl::Init() 189 { 190 DBG_CHKTHIS(OTableEditorCtrl,NULL); 191 OTableRowView::Init(); 192 193 ////////////////////////////////////////////////////////////////////// 194 // Soll der Entwurf ReadOnly geoeffnet werden ? 195 sal_Bool bRead(GetView()->getController().isReadOnly()); 196 197 SetReadOnly( bRead ); 198 199 ////////////////////////////////////////////////////////////////////// 200 // Spalten einfuegen 201 String aColumnName( ModuleRes(STR_TAB_FIELD_COLUMN_NAME) ); 202 InsertDataColumn( FIELD_NAME, aColumnName, FIELDNAME_WIDTH ); 203 204 aColumnName = String( ModuleRes(STR_TAB_FIELD_COLUMN_DATATYPE) ); 205 InsertDataColumn( FIELD_TYPE, aColumnName, FIELDTYPE_WIDTH ); 206 207 ::dbaccess::ODsnTypeCollection aDsnTypes(GetView()->getController().getORB()); 208 sal_Bool bShowColumnDescription = aDsnTypes.supportsColumnDescription(::comphelper::getString(GetView()->getController().getDataSource()->getPropertyValue(PROPERTY_URL))); 209 aColumnName = String( ModuleRes(STR_TAB_HELP_TEXT) ); 210 InsertDataColumn( HELP_TEXT, aColumnName, bShowColumnDescription ? FIELDTYPE_WIDTH : FIELDDESCR_WIDTH ); 211 212 if ( bShowColumnDescription ) 213 { 214 aColumnName = String( ModuleRes(STR_COLUMN_DESCRIPTION) ); 215 InsertDataColumn( COLUMN_DESCRIPTION, aColumnName, FIELDTYPE_WIDTH ); 216 } 217 218 InitCellController(); 219 220 ////////////////////////////////////////////////////////////////////// 221 // Zeilen einfuegen 222 RowInserted(0, m_pRowList->size(), sal_True); 223 } 224 225 //================================================================== 226 void OTableEditorCtrl::UpdateAll() 227 { 228 DBG_CHKTHIS(OTableEditorCtrl,NULL); 229 RowRemoved(0, GetRowCount(), sal_False); 230 m_nDataPos = 0; 231 232 InvalidateFeatures(); 233 Invalidate(); 234 } 235 //================================================================== 236 OTableEditorCtrl::OTableEditorCtrl(Window* pWindow) 237 :OTableRowView(pWindow) 238 ,pNameCell(NULL) 239 ,pTypeCell(NULL) 240 ,pHelpTextCell(NULL) 241 ,pDescrCell(NULL) 242 ,pDescrWin(NULL) 243 ,nIndexEvent(0) 244 ,nCutEvent(0) 245 ,nPasteEvent(0) 246 ,nDeleteEvent(0) 247 ,nInsNewRowsEvent(0) 248 ,nInvalidateTypeEvent(0) 249 ,nEntryNotFoundEvent(0) 250 ,m_eChildFocus(NONE) 251 ,nOldDataPos(-1) 252 ,bSaveOnMove(sal_True) 253 ,bReadOnly(sal_True) 254 ,m_aInvalidate(500,this) 255 { 256 DBG_CTOR(OTableEditorCtrl,NULL); 257 258 SetHelpId(HID_TABDESIGN_BACKGROUND); 259 GetDataWindow().SetHelpId(HID_CTL_TABLEEDIT); 260 261 m_pRowList = GetView()->getController().getRows(); 262 m_nDataPos = 0; 263 } 264 265 //------------------------------------------------------------------------------ 266 SfxUndoManager& OTableEditorCtrl::GetUndoManager() const 267 { 268 return GetView()->getController().GetUndoManager(); 269 } 270 271 //------------------------------------------------------------------------------ 272 sal_Bool OTableEditorCtrl::IsReadOnly() 273 { 274 DBG_CHKTHIS(OTableEditorCtrl,NULL); 275 return bReadOnly; 276 } 277 278 //------------------------------------------------------------------------------ 279 void OTableEditorCtrl::SetReadOnly( sal_Bool bRead ) 280 { 281 // nix zu tun ? 282 if (bRead == IsReadOnly()) 283 // diese Abfrage ist wichtig, da die zugrundeliegende Def sonst im folgenden gelockt oder ge-unlocked wird, obwohl es 284 // nicht notwendig waere (und was schlimmer ist, das wuerde dann auch nicht wieder rueckgaengig gemacht) 285 return; 286 287 DBG_CHKTHIS(OTableEditorCtrl,NULL); 288 bReadOnly = bRead; 289 290 ////////////////////////////////////////////////////////////////////// 291 // Aktive Zelle disablen 292 long nRow(GetCurRow()); 293 sal_uInt16 nCol(GetCurColumnId()); 294 DeactivateCell(); 295 296 ////////////////////////////////////////////////////////////////////// 297 // ::com::sun::star::beans::Property Controls disablen 298 // if (pDescrWin) 299 // pDescrWin->SetReadOnly(bReadOnly || !SetDataPtr(nRow) || GetActRow()->IsReadOnly()); 300 301 ////////////////////////////////////////////////////////////////////// 302 // Cursor des Browsers anpassen 303 BrowserMode nMode(BROWSER_COLUMNSELECTION | BROWSER_MULTISELECTION | BROWSER_KEEPSELECTION | 304 BROWSER_HLINESFULL | BROWSER_VLINESFULL|BROWSER_AUTOSIZE_LASTCOL); 305 if( !bReadOnly ) 306 nMode |= BROWSER_HIDECURSOR; 307 SetMode(nMode); 308 309 if( !bReadOnly ) 310 ActivateCell( nRow, nCol ); 311 } 312 313 //------------------------------------------------------------------------------ 314 void OTableEditorCtrl::InitCellController() 315 { 316 DBG_CHKTHIS(OTableEditorCtrl,NULL); 317 ////////////////////////////////////////////////////////////////////// 318 // Zelle Feldname 319 xub_StrLen nMaxTextLen = EDIT_NOLIMIT; 320 ::rtl::OUString sExtraNameChars; 321 Reference<XConnection> xCon; 322 try 323 { 324 xCon = GetView()->getController().getConnection(); 325 Reference< XDatabaseMetaData> xMetaData = xCon.is() ? xCon->getMetaData() : Reference< XDatabaseMetaData>(); 326 327 nMaxTextLen = ((xub_StrLen)xMetaData.is() ? static_cast<xub_StrLen>(xMetaData->getMaxColumnNameLength()) : 0); 328 329 if( nMaxTextLen == 0 ) 330 nMaxTextLen = EDIT_NOLIMIT; 331 sExtraNameChars = xMetaData.is() ? xMetaData->getExtraNameCharacters() : ::rtl::OUString(); 332 333 } 334 catch(SQLException&) 335 { 336 OSL_ASSERT(!"getMaxColumnNameLength"); 337 } 338 339 pNameCell = new OSQLNameEdit( &GetDataWindow(), sExtraNameChars,WB_LEFT ); 340 pNameCell->SetMaxTextLen( nMaxTextLen ); 341 pNameCell->setCheck( isSQL92CheckEnabled(xCon) ); 342 343 344 ////////////////////////////////////////////////////////////////////// 345 // Zelle Typ 346 pTypeCell = new ListBoxControl( &GetDataWindow() ); 347 pTypeCell->SetDropDownLineCount( 15 ); 348 349 ////////////////////////////////////////////////////////////////////// 350 // Zelle Beschreibung 351 pDescrCell = new Edit( &GetDataWindow(), WB_LEFT ); 352 pDescrCell->SetMaxTextLen( MAX_DESCR_LEN ); 353 354 pHelpTextCell = new Edit( &GetDataWindow(), WB_LEFT ); 355 pHelpTextCell->SetMaxTextLen( MAX_DESCR_LEN ); 356 357 pNameCell->SetHelpId(HID_TABDESIGN_NAMECELL); 358 pTypeCell->SetHelpId(HID_TABDESIGN_TYPECELL); 359 pDescrCell->SetHelpId(HID_TABDESIGN_COMMENTCELL); 360 pHelpTextCell->SetHelpId(HID_TABDESIGN_HELPTEXT); 361 362 Size aHeight; 363 const Control* pControls[] = { pTypeCell,pDescrCell,pNameCell,pHelpTextCell}; 364 for(sal_Size i= 0; i < sizeof(pControls)/sizeof(pControls[0]);++i) 365 { 366 const Size aTemp( pControls[i]->GetOptimalSize(WINDOWSIZE_PREFERRED) ); 367 if ( aTemp.Height() > aHeight.Height() ) 368 aHeight.Height() = aTemp.Height(); 369 } // for(int i= 0; i < sizeof(pControls)/sizeof(pControls[0]);++i 370 SetDataRowHeight(aHeight.Height()); 371 372 ClearModified(); 373 } 374 375 //------------------------------------------------------------------------------ 376 void OTableEditorCtrl::ClearModified() 377 { 378 DBG_CHKTHIS(OTableEditorCtrl,NULL); 379 pNameCell->ClearModifyFlag(); 380 pDescrCell->ClearModifyFlag(); 381 pHelpTextCell->ClearModifyFlag(); 382 pTypeCell->SaveValue(); 383 } 384 385 //------------------------------------------------------------------------------ 386 OTableEditorCtrl::~OTableEditorCtrl() 387 { 388 DBG_DTOR(OTableEditorCtrl,NULL); 389 ////////////////////////////////////////////////////////////////////// 390 // Undo-Manager zuruecksetzen 391 GetUndoManager().Clear(); 392 393 ////////////////////////////////////////////////////////////////////// 394 // Moegliche Events aus Queue entfernen 395 if( nCutEvent ) 396 Application::RemoveUserEvent( nCutEvent ); 397 if( nPasteEvent ) 398 Application::RemoveUserEvent( nPasteEvent ); 399 if( nDeleteEvent ) 400 Application::RemoveUserEvent( nDeleteEvent ); 401 if( nInsNewRowsEvent ) 402 Application::RemoveUserEvent( nInsNewRowsEvent ); 403 if( nInvalidateTypeEvent ) 404 Application::RemoveUserEvent( nInvalidateTypeEvent ); 405 if( nEntryNotFoundEvent ) 406 Application::RemoveUserEvent( nEntryNotFoundEvent ); 407 408 ////////////////////////////////////////////////////////////////////// 409 // Controltypen zerstoeren 410 delete pNameCell; 411 delete pTypeCell; 412 delete pDescrCell; 413 delete pHelpTextCell; 414 } 415 416 //------------------------------------------------------------------------------ 417 sal_Bool OTableEditorCtrl::SetDataPtr( long nRow ) 418 { 419 DBG_CHKTHIS(OTableEditorCtrl,NULL); 420 if(nRow == -1) 421 return sal_False; 422 423 OSL_ENSURE((xub_StrLen)nRow < m_pRowList->size(),"Row is greater than size!"); 424 if(nRow >= (long)m_pRowList->size()) 425 return sal_False; 426 pActRow = (*m_pRowList)[nRow]; 427 return pActRow != NULL; 428 } 429 430 //------------------------------------------------------------------------------ 431 sal_Bool OTableEditorCtrl::SeekRow(long _nRow) 432 { 433 // die Basisklasse braucht den Aufruf, da sie sich dort merkt, welche Zeile gepainted wird 434 EditBrowseBox::SeekRow(_nRow); 435 436 DBG_CHKTHIS(OTableEditorCtrl,NULL); 437 m_nCurrentPos = _nRow; 438 return SetDataPtr(_nRow); 439 } 440 441 //------------------------------------------------------------------------------ 442 void OTableEditorCtrl::PaintCell(OutputDevice& rDev, const Rectangle& rRect, 443 sal_uInt16 nColumnId ) const 444 { 445 DBG_CHKTHIS(OTableEditorCtrl,NULL); 446 const String aText( GetCellText( m_nCurrentPos, nColumnId )); 447 const Point aPos(rRect.TopLeft()); 448 const Size TxtSize(GetDataWindow().GetTextWidth(aText), GetDataWindow().GetTextHeight()); 449 450 rDev.Push( PUSH_CLIPREGION ); 451 rDev.SetClipRegion( rRect ); 452 rDev.DrawText( rRect, aText, TEXT_DRAW_LEFT | TEXT_DRAW_VCENTER ); 453 rDev.Pop(); 454 } 455 456 //------------------------------------------------------------------------------ 457 CellController* OTableEditorCtrl::GetController(long nRow, sal_uInt16 nColumnId) 458 { 459 DBG_CHKTHIS(OTableEditorCtrl,NULL); 460 ////////////////////////////////////////////////////////////////////// 461 // Wenn EditorCtrl ReadOnly ist, darf nicht editiert werden 462 Reference<XPropertySet> xTable = GetView()->getController().getTable(); 463 if (IsReadOnly() || ( xTable.is() && 464 xTable->getPropertySetInfo()->hasPropertyByName(PROPERTY_TYPE) && 465 ::comphelper::getString(xTable->getPropertyValue(PROPERTY_TYPE)) == ::rtl::OUString::createFromAscii("VIEW"))) 466 return NULL; 467 468 ////////////////////////////////////////////////////////////////////// 469 // Wenn Zeile ReadOnly ist, darf sie nicht editiert werden 470 SetDataPtr( nRow ); 471 if( pActRow->IsReadOnly() ) 472 return NULL; 473 474 OFieldDescription* pActFieldDescr = pActRow->GetActFieldDescr(); 475 switch (nColumnId) 476 { 477 case FIELD_NAME: 478 return new EditCellController( pNameCell ); 479 case FIELD_TYPE: 480 if (pActFieldDescr && (pActFieldDescr->GetName().getLength() != 0)) 481 return new ListBoxCellController( pTypeCell ); 482 else return NULL; 483 case HELP_TEXT: 484 if (pActFieldDescr && (pActFieldDescr->GetName().getLength() != 0)) 485 return new EditCellController( pHelpTextCell ); 486 else 487 return NULL; 488 case COLUMN_DESCRIPTION: 489 if (pActFieldDescr && (pActFieldDescr->GetName().getLength() != 0)) 490 return new EditCellController( pDescrCell ); 491 else 492 return NULL; 493 default: 494 return NULL; 495 } 496 } 497 498 //------------------------------------------------------------------------------ 499 void OTableEditorCtrl::InitController(CellControllerRef&, long nRow, sal_uInt16 nColumnId) 500 { 501 DBG_CHKTHIS(OTableEditorCtrl,NULL); 502 SeekRow( nRow == -1 ? GetCurRow() : nRow); 503 OFieldDescription* pActFieldDescr = pActRow->GetActFieldDescr(); 504 String aInitString; 505 506 switch (nColumnId) 507 { 508 case FIELD_NAME: 509 if( pActFieldDescr ) 510 aInitString = pActFieldDescr->GetName(); 511 pNameCell->SetText( aInitString ); 512 pNameCell->SaveValue(); 513 break; 514 case FIELD_TYPE: 515 { 516 if ( pActFieldDescr && pActFieldDescr->getTypeInfo() ) 517 aInitString = pActFieldDescr->getTypeInfo()->aUIName; 518 519 ////////////////////////////////////////////////////////////// 520 // Anpassen des ComboBoxInhalts 521 pTypeCell->Clear(); 522 if( !pActFieldDescr ) 523 break; 524 525 const OTypeInfoMap* pTypeInfo = GetView()->getController().getTypeInfo(); 526 OTypeInfoMap::const_iterator aIter = pTypeInfo->begin(); 527 OTypeInfoMap::const_iterator aEnd = pTypeInfo->end(); 528 for(;aIter != aEnd;++aIter) 529 pTypeCell->InsertEntry( aIter->second->aUIName ); 530 pTypeCell->SelectEntry( aInitString ); 531 } 532 533 break; 534 case HELP_TEXT: 535 if( pActFieldDescr ) 536 aInitString = pActFieldDescr->GetHelpText(); 537 pHelpTextCell->SetText( aInitString ); 538 pHelpTextCell->SaveValue(); 539 break; 540 case COLUMN_DESCRIPTION: 541 if( pActFieldDescr ) 542 aInitString = pActFieldDescr->GetDescription(); 543 pDescrCell->SetText( aInitString ); 544 pDescrCell->SaveValue(); 545 break; 546 547 } 548 } 549 550 //------------------------------------------------------------------------------ 551 EditBrowseBox::RowStatus OTableEditorCtrl::GetRowStatus(long nRow) const 552 { 553 DBG_CHKTHIS(OTableEditorCtrl,NULL); 554 ( (OTableEditorCtrl*)this )->SetDataPtr( nRow ); 555 if( !pActRow ) 556 return EditBrowseBox::CLEAN; 557 if (nRow >= 0 && nRow == m_nDataPos) 558 { 559 if( pActRow->IsPrimaryKey() ) 560 return EditBrowseBox::CURRENT_PRIMARYKEY; 561 return EditBrowseBox::CURRENT; 562 } 563 else 564 { 565 if( pActRow->IsPrimaryKey() ) 566 return EditBrowseBox::PRIMARYKEY; 567 return EditBrowseBox::CLEAN; 568 } 569 } 570 571 //------------------------------------------------------------------------------ 572 sal_Bool OTableEditorCtrl::SaveCurRow() 573 { 574 DBG_CHKTHIS(OTableEditorCtrl,NULL); 575 if (GetFieldDescr(GetCurRow()) == NULL) 576 // in der Zeile, in der ich mich i.A. befinde, stehen keine Daten 577 return sal_True; 578 if (!SaveModified()) 579 return sal_False; 580 581 SetDataPtr(GetCurRow()); 582 pDescrWin->SaveData( pActRow->GetActFieldDescr() ); 583 return sal_True; 584 } 585 586 //------------------------------------------------------------------------------ 587 void OTableEditorCtrl::DisplayData(long nRow, sal_Bool bGrabFocus) 588 { 589 // zur richtigen Zelle fahren 590 SetDataPtr(nRow); 591 592 // Editier-Modus temporaer aus 593 sal_Bool bWasEditing = IsEditing(); 594 if (bWasEditing) 595 DeactivateCell(); 596 597 CellControllerRef aTemp; 598 InitController(aTemp, nRow, FIELD_NAME); 599 InitController(aTemp, nRow, FIELD_TYPE); 600 InitController(aTemp, nRow, COLUMN_DESCRIPTION); 601 InitController(aTemp, nRow, HELP_TEXT); 602 603 GoToRow(nRow); 604 // das Description-Window aktualisieren 605 GetView()->GetDescWin()->DisplayData(GetFieldDescr(nRow)); 606 // neu zeichnen 607 RowModified(nRow); 608 609 // wieder an 610 if (bWasEditing || bGrabFocus) 611 ActivateCell(nRow, GetCurColumnId(), bGrabFocus); 612 } 613 614 //------------------------------------------------------------------------------ 615 void OTableEditorCtrl::CursorMoved() 616 { 617 DBG_CHKTHIS(OTableEditorCtrl,NULL); 618 ////////////////////////////////////////////////////////////////////// 619 // Zeilenwechsel ? 620 m_nDataPos = GetCurRow(); 621 if( m_nDataPos != nOldDataPos && m_nDataPos != -1) 622 { 623 CellControllerRef aTemp; 624 InitController(aTemp,m_nDataPos,FIELD_NAME); 625 InitController(aTemp,m_nDataPos,FIELD_TYPE); 626 InitController(aTemp,m_nDataPos,COLUMN_DESCRIPTION); 627 InitController(aTemp,m_nDataPos,HELP_TEXT); 628 } 629 630 OTableRowView::CursorMoved(); 631 } 632 633 //------------------------------------------------------------------------------ 634 sal_Int32 OTableEditorCtrl::HasFieldName( const String& rFieldName ) 635 { 636 DBG_CHKTHIS(OTableEditorCtrl,NULL); 637 638 Reference<XConnection> xCon = GetView()->getController().getConnection(); 639 Reference< XDatabaseMetaData> xMetaData = xCon.is() ? xCon->getMetaData() : Reference< XDatabaseMetaData>(); 640 641 ::comphelper::UStringMixEqual bCase(xMetaData.is() ? xMetaData->supportsMixedCaseQuotedIdentifiers() : sal_True); 642 643 ::std::vector< ::boost::shared_ptr<OTableRow> >::iterator aIter = m_pRowList->begin(); 644 ::std::vector< ::boost::shared_ptr<OTableRow> >::iterator aEnd = m_pRowList->end(); 645 OFieldDescription* pFieldDescr; 646 sal_Int32 nCount(0); 647 for(;aIter != aEnd;++aIter) 648 { 649 pFieldDescr = (*aIter)->GetActFieldDescr(); 650 if( pFieldDescr && bCase(rFieldName,pFieldDescr->GetName())) 651 nCount++; 652 } 653 return nCount; 654 } 655 // -------------------------------------------------------------------------------------- 656 sal_Bool OTableEditorCtrl::SaveData(long nRow, sal_uInt16 nColId) 657 { 658 DBG_CHKTHIS(OTableEditorCtrl,NULL); 659 ////////////////////////////////////////////////////////////// 660 // Zellinhalte in Datenstruktur speichern 661 SetDataPtr( nRow == -1 ? GetCurRow() : nRow); 662 OFieldDescription* pActFieldDescr = pActRow->GetActFieldDescr(); 663 664 switch( nColId) 665 { 666 ////////////////////////////////////////////////////////////// 667 // Speichern Inhalt NameCell 668 case FIELD_NAME: 669 { 670 ////////////////////////////////////////////////////////////// 671 // Wenn kein Name, nichts machen 672 String aName(pNameCell->GetText()); 673 674 if( !aName.Len() ) 675 { 676 ////////////////////////////////////////////////////////////// 677 // Wenn FieldDescr existiert, wurde Feld geloescht und alter Inhalt wird wiederhergestellt 678 if (pActFieldDescr) 679 { 680 GetUndoManager().AddUndoAction(new OTableEditorTypeSelUndoAct(this, nRow, FIELD_TYPE, pActFieldDescr->getTypeInfo())); 681 SwitchType(TOTypeInfoSP()); 682 pActFieldDescr = pActRow->GetActFieldDescr(); 683 } 684 else 685 return sal_True; 686 } 687 if(pActFieldDescr) 688 pActFieldDescr->SetName( aName ); 689 pNameCell->ClearModifyFlag(); 690 691 break; 692 } 693 694 ////////////////////////////////////////////////////////////// 695 // Speichern Inhalt TypeCell 696 case FIELD_TYPE: 697 break; 698 699 ////////////////////////////////////////////////////////////// 700 // Speichern Inhalt DescrCell 701 case HELP_TEXT: 702 { 703 ////////////////////////////////////////////////////////////// 704 // Wenn aktuelle Feldbeschreibung NULL, Default setzen 705 if( !pActFieldDescr ) 706 { 707 pHelpTextCell->SetText(String()); 708 pHelpTextCell->ClearModifyFlag(); 709 } 710 else 711 pActFieldDescr->SetHelpText( pHelpTextCell->GetText() ); 712 break; 713 } 714 case COLUMN_DESCRIPTION: 715 { 716 ////////////////////////////////////////////////////////////// 717 // Wenn aktuelle Feldbeschreibung NULL, Default setzen 718 if( !pActFieldDescr ) 719 { 720 pDescrCell->SetText(String()); 721 pDescrCell->ClearModifyFlag(); 722 } 723 else 724 pActFieldDescr->SetDescription( pDescrCell->GetText() ); 725 break; 726 } 727 case FIELD_PROPERTY_DEFAULT: 728 case FIELD_PROPERTY_REQUIRED: 729 case FIELD_PROPERTY_TEXTLEN: 730 case FIELD_PROPERTY_NUMTYPE: 731 case FIELD_PROPERTY_AUTOINC: 732 case FIELD_PROPERTY_LENGTH: 733 case FIELD_PROPERTY_SCALE: 734 case FIELD_PROPERTY_BOOL_DEFAULT: 735 pDescrWin->SaveData(pActFieldDescr); 736 737 if ( FIELD_PROPERTY_AUTOINC == nColId && pActFieldDescr->IsAutoIncrement() ) 738 { 739 OTableController& rController = GetView()->getController(); 740 if ( rController.isAutoIncrementPrimaryKey() ) 741 { 742 pActFieldDescr->SetPrimaryKey( true ); 743 InvalidateHandleColumn(); 744 Invalidate(); 745 } 746 } 747 break; 748 } 749 return sal_True; 750 } 751 752 //------------------------------------------------------------------------------ 753 sal_Bool OTableEditorCtrl::SaveModified() 754 { 755 DBG_CHKTHIS(OTableEditorCtrl,NULL); 756 sal_uInt16 nColId = GetCurColumnId(); 757 758 switch( nColId ) 759 { 760 ////////////////////////////////////////////////////////////// 761 // NameCell 762 case FIELD_NAME: 763 { 764 // removed the former duplicate-check. this is done in OTableDocShell::CheckDefConsistency now. 765 // FS - 07.12.99 - 69575 766 767 } break; 768 769 ////////////////////////////////////////////////////////////// 770 // TypeCell 771 case FIELD_TYPE: 772 { 773 ////////////////////////////////////////////////////////////////////// 774 // Type umstellen 775 resetType(); 776 } break; 777 } 778 779 return sal_True; 780 } 781 782 //------------------------------------------------------------------------------ 783 sal_Bool OTableEditorCtrl::CursorMoving(long nNewRow, sal_uInt16 nNewCol) 784 { 785 DBG_CHKTHIS(OTableEditorCtrl,NULL); 786 787 if (!EditBrowseBox::CursorMoving(nNewRow, nNewCol)) 788 return sal_False; 789 790 ////////////////////////////////////////////////////////////////////// 791 // Wird nach SaveModified() gerufen, aktuelle Zeile ist noch die alte 792 m_nDataPos = nNewRow; 793 nOldDataPos = GetCurRow(); 794 795 ////////////////////////////////////////////////////////////////////// 796 // Marker umsetzen 797 InvalidateStatusCell( nOldDataPos ); 798 InvalidateStatusCell( m_nDataPos ); 799 800 ////////////////////////////////////////////////////////////////////// 801 // Daten des Propertyfensters speichern 802 if( SetDataPtr(nOldDataPos) && pDescrWin) 803 pDescrWin->SaveData( pActRow->GetActFieldDescr() ); 804 805 ////////////////////////////////////////////////////////////////////// 806 // Neue Daten im Propertyfenster anzeigen 807 if( SetDataPtr(m_nDataPos) && pDescrWin) 808 pDescrWin->DisplayData( pActRow->GetActFieldDescr() ); 809 810 return sal_True; 811 } 812 813 //------------------------------------------------------------------------------ 814 IMPL_LINK( OTableEditorCtrl, InvalidateFieldType, void*, /*EMPTYTAG*/ ) 815 { 816 DBG_CHKTHIS(OTableEditorCtrl,NULL); 817 nInvalidateTypeEvent = 0; 818 Invalidate( GetFieldRectPixel(nOldDataPos, FIELD_TYPE) ); 819 820 return 0; 821 } 822 823 //------------------------------------------------------------------------------ 824 IMPL_LINK( OTableEditorCtrl, EntryNotFound, void*, /*EMPTYTAG*/ ) 825 { 826 DBG_CHKTHIS(OTableEditorCtrl,NULL); 827 nEntryNotFoundEvent = 0; 828 ErrorBox( this, ModuleRes(ERR_INVALID_LISTBOX_ENTRY) ).Execute(); 829 830 return 0; 831 } 832 833 //------------------------------------------------------------------------------ 834 void OTableEditorCtrl::CellModified( long nRow, sal_uInt16 nColId ) 835 { 836 DBG_CHKTHIS(OTableEditorCtrl,NULL); 837 838 ////////////////////////////////////////////////////////////// 839 // Wenn aktuelle Feldbeschreibung NULL, Default setzen 840 if(nRow == -1) 841 nRow = GetCurRow(); 842 SetDataPtr( nRow ); 843 OFieldDescription* pActFieldDescr = pActRow->GetActFieldDescr(); 844 845 String sActionDescription; 846 switch ( nColId ) 847 { 848 case FIELD_NAME: sActionDescription = String( ModuleRes( STR_CHANGE_COLUMN_NAME ) ); break; 849 case FIELD_TYPE: sActionDescription = String( ModuleRes( STR_CHANGE_COLUMN_TYPE ) ); break; 850 case HELP_TEXT: 851 case COLUMN_DESCRIPTION: sActionDescription = String( ModuleRes( STR_CHANGE_COLUMN_DESCRIPTION ) ); break; 852 default: sActionDescription = String( ModuleRes( STR_CHANGE_COLUMN_ATTRIBUTE ) ); break; 853 } 854 855 GetUndoManager().EnterListAction( sActionDescription, String() ); 856 if (!pActFieldDescr) 857 { 858 const OTypeInfoMap* pTypeInfoMap = GetView()->getController().getTypeInfo(); 859 if ( !pTypeInfoMap->empty() ) 860 { 861 OTypeInfoMap::const_iterator aTypeIter = pTypeInfoMap->find(DataType::VARCHAR); 862 if ( aTypeIter == pTypeInfoMap->end() ) 863 aTypeIter = pTypeInfoMap->begin(); 864 pActRow->SetFieldType( aTypeIter->second ); 865 } 866 else 867 pActRow->SetFieldType( GetView()->getController().getTypeInfoFallBack() ); 868 869 nInvalidateTypeEvent = Application::PostUserEvent( LINK(this, OTableEditorCtrl, InvalidateFieldType) ); 870 pActFieldDescr = pActRow->GetActFieldDescr(); 871 pDescrWin->DisplayData( pActFieldDescr ); 872 GetUndoManager().AddUndoAction( new OTableEditorTypeSelUndoAct(this, nRow, nColId+1, TOTypeInfoSP()) ); 873 } 874 875 if( nColId != FIELD_TYPE ) 876 GetUndoManager().AddUndoAction( new OTableDesignCellUndoAct(this, nRow, nColId) ); 877 else 878 { 879 GetUndoManager().AddUndoAction(new OTableEditorTypeSelUndoAct(this, GetCurRow(), nColId, GetFieldDescr(GetCurRow())->getTypeInfo())); 880 resetType(); 881 } 882 883 SaveData(nRow,nColId); 884 // SaveData could create a undo action as well 885 GetUndoManager().LeaveListAction(); 886 RowModified(nRow); 887 CellControllerRef xController(Controller()); 888 if(xController.Is()) 889 xController->SetModified(); 890 891 ////////////////////////////////////////////////////////////////////// 892 // Das ModifyFlag setzen 893 GetView()->getController().setModified( sal_True ); 894 InvalidateFeatures(); 895 } 896 // ----------------------------------------------------------------------------- 897 void OTableEditorCtrl::resetType() 898 { 899 sal_uInt16 nPos = pTypeCell->GetSelectEntryPos(); 900 if(nPos != LISTBOX_ENTRY_NOTFOUND) 901 SwitchType( GetView()->getController().getTypeInfo(nPos) ); 902 else 903 SwitchType(TOTypeInfoSP()); 904 } 905 //------------------------------------------------------------------------------ 906 void OTableEditorCtrl::CellModified() 907 { 908 DBG_CHKTHIS(OTableEditorCtrl,NULL); 909 CellModified( GetCurRow(), GetCurColumnId() ); 910 } 911 // ----------------------------------------------------------------------------- 912 void OTableEditorCtrl::InvalidateFeatures() 913 { 914 GetView()->getController().InvalidateFeature(SID_UNDO); 915 GetView()->getController().InvalidateFeature(SID_REDO); 916 GetView()->getController().InvalidateFeature(SID_SAVEDOC); 917 } 918 //------------------------------------------------------------------------------ 919 void OTableEditorCtrl::Undo() 920 { 921 DBG_CHKTHIS(OTableEditorCtrl,NULL); 922 923 InvalidateFeatures(); 924 } 925 //------------------------------------------------------------------------------ 926 void OTableEditorCtrl::Redo() 927 { 928 DBG_CHKTHIS(OTableEditorCtrl,NULL); 929 InvalidateFeatures(); 930 } 931 932 //------------------------------------------------------------------------------ 933 void OTableEditorCtrl::CopyRows() 934 { 935 DBG_CHKTHIS(OTableEditorCtrl,NULL); 936 ////////////////////////////////////////////////////////////////////// 937 // set to the right row and save it 938 if( SetDataPtr(m_nDataPos) ) 939 pDescrWin->SaveData( pActRow->GetActFieldDescr() ); 940 941 ////////////////////////////////////////////////////////////////////// 942 // Selektierte Zeilen in die ClipboardListe kopieren 943 ::boost::shared_ptr<OTableRow> pClipboardRow; 944 ::boost::shared_ptr<OTableRow> pRow; 945 ::std::vector< ::boost::shared_ptr<OTableRow> > vClipboardList; 946 vClipboardList.reserve(GetSelectRowCount()); 947 948 for( long nIndex=FirstSelectedRow(); nIndex >= 0 && nIndex < static_cast<long>(m_pRowList->size()); nIndex=NextSelectedRow() ) 949 { 950 pRow = (*m_pRowList)[nIndex]; 951 OSL_ENSURE(pRow,"OTableEditorCtrl::CopyRows: Row is NULL!"); 952 if ( pRow && pRow->GetActFieldDescr() ) 953 { 954 pClipboardRow.reset(new OTableRow( *pRow )); 955 vClipboardList.push_back( pClipboardRow); 956 } 957 } 958 if(!vClipboardList.empty()) 959 { 960 OTableRowExchange* pData = new OTableRowExchange(vClipboardList); 961 Reference< ::com::sun::star::datatransfer::XTransferable> xRef = pData; 962 pData->CopyToClipboard(GetParent()); 963 } 964 } 965 966 //------------------------------------------------------------------------------ 967 String OTableEditorCtrl::GenerateName( const String& rName ) 968 { 969 DBG_CHKTHIS(OTableEditorCtrl,NULL); 970 ////////////////////////////////////////////////////////////////////// 971 // Basisnamen zum Anhaengen einer Numerierung erstellen 972 String aBaseName; 973 Reference<XConnection> xCon = GetView()->getController().getConnection(); 974 Reference< XDatabaseMetaData> xMetaData = xCon.is() ? xCon->getMetaData() : Reference< XDatabaseMetaData>(); 975 976 xub_StrLen nMaxTextLen((xub_StrLen)( xMetaData.is() ? xMetaData->getMaxColumnNameLength() : 0)); 977 978 if( (rName.Len()+2) >nMaxTextLen ) 979 aBaseName = rName.Copy( 0, nMaxTextLen-2 ); 980 else 981 aBaseName = rName; 982 983 ////////////////////////////////////////////////////////////////////// 984 // Namen durchnumerieren (bis 99) 985 String aFieldName( rName); 986 sal_Int32 i=1; 987 while( HasFieldName(aFieldName) ) 988 { 989 aFieldName = aBaseName; 990 aFieldName += String::CreateFromInt32(i); 991 i++; 992 } 993 994 return aFieldName; 995 } 996 997 //------------------------------------------------------------------------------ 998 void OTableEditorCtrl::InsertRows( long nRow ) 999 { 1000 DBG_CHKTHIS(OTableEditorCtrl,NULL); 1001 1002 ::std::vector< ::boost::shared_ptr<OTableRow> > vInsertedUndoRedoRows; // need for undo/redo handling 1003 ////////////////////////////////////////////////////////////////////// 1004 // get rows from clipboard 1005 TransferableDataHelper aTransferData(TransferableDataHelper::CreateFromSystemClipboard(GetParent())); 1006 if(aTransferData.HasFormat(SOT_FORMATSTR_ID_SBA_TABED)) 1007 { 1008 SotStorageStreamRef aStreamRef; 1009 aTransferData.GetSotStorageStream(SOT_FORMATSTR_ID_SBA_TABED,aStreamRef); 1010 if(aStreamRef.Is()) 1011 { 1012 aStreamRef->Seek(STREAM_SEEK_TO_BEGIN); 1013 aStreamRef->ResetError(); 1014 long nInsertRow = nRow; 1015 String aFieldName; 1016 ::boost::shared_ptr<OTableRow> pRow; 1017 sal_Int32 nSize = 0; 1018 (*aStreamRef) >> nSize; 1019 vInsertedUndoRedoRows.reserve(nSize); 1020 for(sal_Int32 i=0;i < nSize;++i) 1021 { 1022 pRow.reset(new OTableRow()); 1023 (*aStreamRef) >> *pRow; 1024 pRow->SetReadOnly( sal_False ); 1025 sal_Int32 nType = pRow->GetActFieldDescr()->GetType(); 1026 if ( pRow->GetActFieldDescr() ) 1027 pRow->GetActFieldDescr()->SetType(GetView()->getController().getTypeInfoByType(nType)); 1028 ////////////////////////////////////////////////////////////////////// 1029 // Anpassen des Feldnamens 1030 aFieldName = GenerateName( pRow->GetActFieldDescr()->GetName() ); 1031 pRow->GetActFieldDescr()->SetName( aFieldName ); 1032 pRow->SetPos(nInsertRow); 1033 m_pRowList->insert( m_pRowList->begin()+nInsertRow,pRow ); 1034 vInsertedUndoRedoRows.push_back(::boost::shared_ptr<OTableRow>(new OTableRow(*pRow))); 1035 nInsertRow++; 1036 } 1037 } 1038 } 1039 ////////////////////////////////////////////////////////////////////// 1040 // Beim RowInserted wird CursorMoved gerufen. 1041 // Die UI-Daten duerfen hier beim CursorMoved nicht gespeichert werden. 1042 bSaveOnMove = sal_False; 1043 RowInserted( nRow,vInsertedUndoRedoRows.size(),sal_True ); 1044 bSaveOnMove = sal_True; 1045 1046 ////////////////////////////////////////////////////////////////////// 1047 // Undo-Action erzeugen 1048 GetUndoManager().AddUndoAction( new OTableEditorInsUndoAct(this, nRow,vInsertedUndoRedoRows) ); 1049 GetView()->getController().setModified( sal_True ); 1050 InvalidateFeatures(); 1051 } 1052 1053 //------------------------------------------------------------------------------ 1054 void OTableEditorCtrl::DeleteRows() 1055 { 1056 DBG_CHKTHIS(OTableEditorCtrl,NULL); 1057 OSL_ENSURE(GetView()->getController().isDropAllowed(),"Call of DeleteRows not valid here. Please check isDropAllowed!"); 1058 ////////////////////////////////////////////////////////////////////// 1059 // Undo-Action erzeugen 1060 GetUndoManager().AddUndoAction( new OTableEditorDelUndoAct(this) ); 1061 1062 1063 ////////////////////////////////////////////////////////////////////// 1064 // Alle markierten Zeilen loeschen 1065 long nIndex = FirstSelectedRow(); 1066 nOldDataPos = nIndex; 1067 bSaveOnMove = sal_False; 1068 1069 while( nIndex >= 0 && nIndex < static_cast<long>(m_pRowList->size()) ) 1070 { 1071 ////////////////////////////////////////////////////////////////////// 1072 // Zeile entfernen 1073 m_pRowList->erase( m_pRowList->begin()+nIndex ); 1074 RowRemoved( nIndex, 1, sal_True ); 1075 1076 ////////////////////////////////////////////////////////////////////// 1077 // Leerzeile am Ende wieder einfuegen 1078 m_pRowList->push_back( ::boost::shared_ptr<OTableRow>(new OTableRow())); 1079 RowInserted( GetRowCount()-1, 1, sal_True ); 1080 1081 nIndex = FirstSelectedRow(); 1082 } 1083 1084 bSaveOnMove = sal_True; 1085 1086 ////////////////////////////////////////////////////////////////////// 1087 // Erzwingen, dass der aktuelle Datensatz angezeigt wird 1088 m_nDataPos = GetCurRow(); 1089 InvalidateStatusCell( nOldDataPos ); 1090 InvalidateStatusCell( m_nDataPos ); 1091 SetDataPtr( m_nDataPos ); 1092 ActivateCell(); 1093 pDescrWin->DisplayData( pActRow->GetActFieldDescr() ); 1094 GetView()->getController().setModified( sal_True ); 1095 InvalidateFeatures(); 1096 } 1097 1098 //------------------------------------------------------------------------------ 1099 void OTableEditorCtrl::InsertNewRows( long nRow ) 1100 { 1101 DBG_CHKTHIS(OTableEditorCtrl,NULL); 1102 OSL_ENSURE(GetView()->getController().isAddAllowed(),"Call of InsertNewRows not valid here. Please check isAppendAllowed!"); 1103 ////////////////////////////////////////////////////////////////////// 1104 // Undo-Action erzeugen 1105 long nInsertRows = GetSelectRowCount(); 1106 if( !nInsertRows ) 1107 nInsertRows = 1; 1108 GetUndoManager().AddUndoAction( new OTableEditorInsNewUndoAct(this, nRow, nInsertRows) ); 1109 ////////////////////////////////////////////////////////////////////// 1110 // Zahl der selektierten Zeilen werden neu eingefuegt 1111 for( long i=nRow; i<(nRow+nInsertRows); i++ ) 1112 m_pRowList->insert( m_pRowList->begin()+i ,::boost::shared_ptr<OTableRow>(new OTableRow())); 1113 RowInserted( nRow, nInsertRows, sal_True ); 1114 1115 GetView()->getController().setModified( sal_True ); 1116 InvalidateFeatures(); 1117 } 1118 1119 //------------------------------------------------------------------------------ 1120 String OTableEditorCtrl::GetControlText( long nRow, sal_uInt16 nColId ) 1121 { 1122 DBG_CHKTHIS(OTableEditorCtrl,NULL); 1123 ////////////////////////////////////////////////////////////////////// 1124 // Controls des Browsers auslesen 1125 if( nColId < FIELD_FIRST_VIRTUAL_COLUMN ) 1126 { 1127 GoToRow( nRow ); 1128 GoToColumnId( nColId ); 1129 CellControllerRef xController = Controller(); 1130 if(xController.Is()) 1131 return xController->GetWindow().GetText(); 1132 else 1133 return GetCellText(nRow,nColId); 1134 } 1135 1136 ////////////////////////////////////////////////////////////////////// 1137 // Controls der Tabpage Auslesen 1138 else 1139 return pDescrWin->GetControlText( nColId ); 1140 } 1141 1142 //------------------------------------------------------------------------------ 1143 void OTableEditorCtrl::SetControlText( long nRow, sal_uInt16 nColId, const String& rText ) 1144 { 1145 DBG_CHKTHIS(OTableEditorCtrl,NULL); 1146 ////////////////////////////////////////////////////////////////////// 1147 // Controls des Browsers setzen 1148 if( nColId < FIELD_FIRST_VIRTUAL_COLUMN ) 1149 { 1150 GoToRow( nRow ); 1151 GoToColumnId( nColId ); 1152 CellControllerRef xController = Controller(); 1153 if(xController.Is()) 1154 xController->GetWindow().SetText( rText ); 1155 else 1156 RowModified(nRow,nColId); 1157 } 1158 1159 ////////////////////////////////////////////////////////////////////// 1160 // Controls der Tabpage setzen 1161 else 1162 { 1163 pDescrWin->SetControlText( nColId, rText ); 1164 } 1165 } 1166 //------------------------------------------------------------------------------ 1167 void OTableEditorCtrl::SetCellData( long nRow, sal_uInt16 nColId, const TOTypeInfoSP& _pTypeInfo ) 1168 { 1169 DBG_CHKTHIS(OTableEditorCtrl,NULL); 1170 ////////////////////////////////////////////////////////////////////// 1171 // Aktuellen Datenzeiger umsetzen 1172 if( nRow == -1 ) 1173 nRow = GetCurRow(); 1174 OFieldDescription* pFieldDescr = GetFieldDescr( nRow ); 1175 if( !pFieldDescr && nColId != FIELD_TYPE) 1176 return; 1177 1178 ////////////////////////////////////////////////////////////////////// 1179 // Einzelne Felder setzen 1180 switch( nColId ) 1181 { 1182 case FIELD_TYPE: 1183 SwitchType( _pTypeInfo ); 1184 break; 1185 default: 1186 OSL_ENSURE(sal_False, "OTableEditorCtrl::SetCellData: invalid column!"); 1187 } 1188 SetControlText(nRow,nColId,_pTypeInfo.get() ? _pTypeInfo->aUIName : ::rtl::OUString()); 1189 } 1190 //------------------------------------------------------------------------------ 1191 void OTableEditorCtrl::SetCellData( long nRow, sal_uInt16 nColId, const ::com::sun::star::uno::Any& _rNewData ) 1192 { 1193 DBG_CHKTHIS(OTableEditorCtrl,NULL); 1194 ////////////////////////////////////////////////////////////////////// 1195 // Aktuellen Datenzeiger umsetzen 1196 if( nRow == -1 ) 1197 nRow = GetCurRow(); 1198 OFieldDescription* pFieldDescr = GetFieldDescr( nRow ); 1199 if( !pFieldDescr && nColId != FIELD_TYPE) 1200 return; 1201 1202 String sValue; 1203 ////////////////////////////////////////////////////////////////////// 1204 // Einzelne Felder setzen 1205 switch( nColId ) 1206 { 1207 case FIELD_NAME: 1208 sValue = ::comphelper::getString(_rNewData); 1209 pFieldDescr->SetName( sValue ); 1210 break; 1211 1212 case FIELD_TYPE: 1213 OSL_ENSURE(sal_False, "OTableEditorCtrl::SetCellData: invalid column!"); 1214 break; 1215 1216 case COLUMN_DESCRIPTION: 1217 pFieldDescr->SetDescription( sValue = ::comphelper::getString(_rNewData) ); 1218 break; 1219 1220 case FIELD_PROPERTY_DEFAULT: 1221 pFieldDescr->SetControlDefault( _rNewData ); 1222 sValue = GetView()->GetDescWin()->getGenPage()->getFieldControl()->getControlDefault(pFieldDescr); 1223 break; 1224 1225 case FIELD_PROPERTY_REQUIRED: 1226 { 1227 sValue = ::comphelper::getString(_rNewData); 1228 pFieldDescr->SetIsNullable( sValue.ToInt32() ); 1229 } 1230 break; 1231 1232 case FIELD_PROPERTY_TEXTLEN: 1233 case FIELD_PROPERTY_LENGTH: 1234 { 1235 sValue = ::comphelper::getString(_rNewData); 1236 pFieldDescr->SetPrecision( sValue.ToInt32() ); 1237 } 1238 break; 1239 1240 case FIELD_PROPERTY_NUMTYPE: 1241 // pFieldDescr->SetNumType( _rNewData ); 1242 OSL_ENSURE(sal_False, "OTableEditorCtrl::SetCellData: invalid column!"); 1243 break; 1244 1245 case FIELD_PROPERTY_AUTOINC: 1246 { 1247 String strYes(ModuleRes(STR_VALUE_YES)); 1248 sValue = ::comphelper::getString(_rNewData); 1249 pFieldDescr->SetAutoIncrement(sValue.Equals(strYes)); 1250 } 1251 break; 1252 case FIELD_PROPERTY_SCALE: 1253 { 1254 sValue = ::comphelper::getString(_rNewData); 1255 pFieldDescr->SetScale(sValue.ToInt32()); 1256 } 1257 break; 1258 1259 case FIELD_PROPERTY_BOOL_DEFAULT: 1260 sValue = GetView()->GetDescWin()->BoolStringPersistent(::comphelper::getString(_rNewData)); 1261 pFieldDescr->SetControlDefault(makeAny(::rtl::OUString(sValue))); 1262 break; 1263 1264 case FIELD_PROPERTY_FORMAT: 1265 { 1266 sValue = ::comphelper::getString(_rNewData); 1267 pFieldDescr->SetFormatKey(sValue.ToInt32()); 1268 } 1269 break; 1270 } 1271 1272 SetControlText(nRow,nColId,sValue); 1273 } 1274 1275 //------------------------------------------------------------------------------ 1276 Any OTableEditorCtrl::GetCellData( long nRow, sal_uInt16 nColId ) 1277 { 1278 DBG_CHKTHIS(OTableEditorCtrl,NULL); 1279 OFieldDescription* pFieldDescr = GetFieldDescr( nRow ); 1280 if( !pFieldDescr ) 1281 return Any(); 1282 1283 ////////////////////////////////////////////////////////////////////// 1284 // Aktuellen Datenzeiger umsetzen 1285 if( nRow==-1 ) 1286 nRow = GetCurRow(); 1287 SetDataPtr( nRow ); 1288 1289 static const String strYes(ModuleRes(STR_VALUE_YES)); 1290 static const String strNo(ModuleRes(STR_VALUE_NO)); 1291 ::rtl::OUString sValue; 1292 ////////////////////////////////////////////////////////////////////// 1293 // Einzelne Felder auslesen 1294 switch( nColId ) 1295 { 1296 case FIELD_NAME: 1297 sValue = pFieldDescr->GetName(); 1298 break; 1299 1300 case FIELD_TYPE: 1301 if ( pFieldDescr->getTypeInfo() ) 1302 sValue = pFieldDescr->getTypeInfo()->aUIName; 1303 break; 1304 1305 case COLUMN_DESCRIPTION: 1306 sValue = pFieldDescr->GetDescription(); 1307 break; 1308 case HELP_TEXT: 1309 sValue = pFieldDescr->GetHelpText(); 1310 break; 1311 1312 case FIELD_PROPERTY_DEFAULT: 1313 return pFieldDescr->GetControlDefault(); 1314 1315 case FIELD_PROPERTY_REQUIRED: 1316 sValue = pFieldDescr->GetIsNullable() == ColumnValue::NULLABLE ? strYes : strNo; 1317 break; 1318 1319 case FIELD_PROPERTY_TEXTLEN: 1320 case FIELD_PROPERTY_LENGTH: 1321 sValue = String::CreateFromInt32(pFieldDescr->GetPrecision()); 1322 break; 1323 1324 case FIELD_PROPERTY_NUMTYPE: 1325 OSL_ENSURE(sal_False, "OTableEditorCtrl::GetCellData: invalid column!"); 1326 // return pFieldDescr->GetNumType(); 1327 1328 case FIELD_PROPERTY_AUTOINC: 1329 sValue = pFieldDescr->IsAutoIncrement() ? strYes : strNo; 1330 break; 1331 1332 case FIELD_PROPERTY_SCALE: 1333 sValue = String::CreateFromInt32(pFieldDescr->GetScale()); 1334 break; 1335 1336 case FIELD_PROPERTY_BOOL_DEFAULT: 1337 sValue = GetView()->GetDescWin()->BoolStringUI(::comphelper::getString(pFieldDescr->GetControlDefault())); 1338 break; 1339 1340 case FIELD_PROPERTY_FORMAT: 1341 sValue = String::CreateFromInt32(pFieldDescr->GetFormatKey()); 1342 break; 1343 } 1344 1345 return makeAny(sValue); 1346 } 1347 1348 //------------------------------------------------------------------------------ 1349 String OTableEditorCtrl::GetCellText( long nRow, sal_uInt16 nColId ) const 1350 { 1351 DBG_CHKTHIS(OTableEditorCtrl,NULL); 1352 ::rtl::OUString sCellText; 1353 const_cast< OTableEditorCtrl* >( this )->GetCellData( nRow, nColId ) >>= sCellText; 1354 return sCellText; 1355 } 1356 1357 //------------------------------------------------------------------------------ 1358 sal_uInt32 OTableEditorCtrl::GetTotalCellWidth(long nRow, sal_uInt16 nColId) 1359 { 1360 DBG_CHKTHIS(OTableEditorCtrl,NULL); 1361 return GetTextWidth(GetCellText(nRow, nColId)) + 2 * GetTextWidth('0'); 1362 } 1363 1364 //------------------------------------------------------------------------------ 1365 OFieldDescription* OTableEditorCtrl::GetFieldDescr( long nRow ) 1366 { 1367 DBG_CHKTHIS(OTableEditorCtrl,NULL); 1368 std::vector< ::boost::shared_ptr<OTableRow> >::size_type nListCount( 1369 m_pRowList->size()); 1370 if( (nRow<0) || (sal::static_int_cast< unsigned long >(nRow)>=nListCount) ) 1371 { 1372 OSL_ENSURE(0,"(nRow<0) || (nRow>=nListCount)"); 1373 return NULL; 1374 } 1375 ::boost::shared_ptr<OTableRow> pRow = (*m_pRowList)[ nRow ]; 1376 if( !pRow ) 1377 return NULL; 1378 return pRow->GetActFieldDescr(); 1379 } 1380 1381 //------------------------------------------------------------------------------ 1382 sal_Bool OTableEditorCtrl::IsCutAllowed( long nRow ) 1383 { 1384 DBG_CHKTHIS(OTableEditorCtrl,NULL); 1385 sal_Bool bIsCutAllowed = (GetView()->getController().isAddAllowed() && GetView()->getController().isDropAllowed()) || 1386 GetView()->getController().isAlterAllowed(); 1387 1388 if(bIsCutAllowed) 1389 { 1390 switch(m_eChildFocus) 1391 { 1392 case DESCRIPTION: 1393 bIsCutAllowed = pDescrCell->GetSelected().Len() != 0; 1394 break; 1395 case HELPTEXT: 1396 bIsCutAllowed = pHelpTextCell->GetSelected().Len() != 0; 1397 break; 1398 case NAME: 1399 bIsCutAllowed = pNameCell->GetSelected().Len() != 0; 1400 break; 1401 case ROW: 1402 bIsCutAllowed = IsCopyAllowed(nRow); 1403 break; 1404 default: 1405 bIsCutAllowed = sal_False; 1406 break; 1407 } 1408 } 1409 1410 // Reference<XPropertySet> xTable = GetView()->getController().getTable(); 1411 // if( !IsCopyAllowed(nRow) || (xTable.is() && ::comphelper::getString(xTable->getPropertyValue(PROPERTY_TYPE)) == ::rtl::OUString::createFromAscii("VIEW"))) 1412 // return sal_False; 1413 1414 // return bCutAllowed && IsDeleteAllowed( nRow ); 1415 return bIsCutAllowed; 1416 } 1417 1418 //------------------------------------------------------------------------------ 1419 sal_Bool OTableEditorCtrl::IsCopyAllowed( long /*nRow*/ ) 1420 { 1421 DBG_CHKTHIS(OTableEditorCtrl,NULL); 1422 sal_Bool bIsCopyAllowed = sal_False; 1423 if(m_eChildFocus == DESCRIPTION ) 1424 bIsCopyAllowed = pDescrCell->GetSelected().Len() != 0; 1425 else if(HELPTEXT == m_eChildFocus ) 1426 bIsCopyAllowed = pHelpTextCell->GetSelected().Len() != 0; 1427 else if(m_eChildFocus == NAME) 1428 bIsCopyAllowed = pNameCell->GetSelected().Len() != 0; 1429 else if(m_eChildFocus == ROW) 1430 { 1431 Reference<XPropertySet> xTable = GetView()->getController().getTable(); 1432 if( !GetSelectRowCount() || (xTable.is() && ::comphelper::getString(xTable->getPropertyValue(PROPERTY_TYPE)) == ::rtl::OUString::createFromAscii("VIEW"))) 1433 return sal_False; 1434 1435 ////////////////////////////////////////////////////////////////////// 1436 // Wenn eine der markierten Zeilen leer ist, kein Copy moeglich 1437 ::boost::shared_ptr<OTableRow> pRow; 1438 long nIndex = FirstSelectedRow(); 1439 while( nIndex >= 0 && nIndex < static_cast<long>(m_pRowList->size()) ) 1440 { 1441 pRow = (*m_pRowList)[nIndex]; 1442 if( !pRow->GetActFieldDescr() ) 1443 return sal_False; 1444 1445 nIndex = NextSelectedRow(); 1446 } 1447 1448 bIsCopyAllowed = sal_True; 1449 } 1450 1451 return bIsCopyAllowed; 1452 } 1453 1454 //------------------------------------------------------------------------------ 1455 sal_Bool OTableEditorCtrl::IsPasteAllowed( long /*nRow*/ ) 1456 { 1457 DBG_CHKTHIS(OTableEditorCtrl,NULL); 1458 sal_Bool bAllowed = GetView()->getController().isAddAllowed(); 1459 if ( bAllowed ) 1460 { 1461 TransferableDataHelper aTransferData(TransferableDataHelper::CreateFromSystemClipboard(GetParent())); 1462 sal_Bool bRowFormat = aTransferData.HasFormat(SOT_FORMATSTR_ID_SBA_TABED); 1463 if ( m_eChildFocus == ROW ) 1464 bAllowed = bRowFormat; 1465 else 1466 bAllowed = !bRowFormat && aTransferData.HasFormat(SOT_FORMAT_STRING); 1467 } 1468 1469 return bAllowed; 1470 } 1471 1472 //------------------------------------------------------------------------------ 1473 void OTableEditorCtrl::cut() 1474 { 1475 if(m_eChildFocus == NAME) 1476 { 1477 if(GetView()->getController().isAlterAllowed()) 1478 { 1479 SaveData(-1,FIELD_NAME); 1480 pNameCell->Cut(); 1481 CellModified(-1,FIELD_NAME); 1482 } 1483 } 1484 else if(m_eChildFocus == DESCRIPTION) 1485 { 1486 if(GetView()->getController().isAlterAllowed()) 1487 { 1488 SaveData(-1,COLUMN_DESCRIPTION); 1489 pDescrCell->Cut(); 1490 CellModified(-1,COLUMN_DESCRIPTION); 1491 } 1492 } 1493 else if(HELPTEXT == m_eChildFocus ) 1494 { 1495 if(GetView()->getController().isAlterAllowed()) 1496 { 1497 SaveData(-1,HELP_TEXT); 1498 pHelpTextCell->Cut(); 1499 CellModified(-1,HELP_TEXT); 1500 } 1501 } 1502 else if(m_eChildFocus == ROW) 1503 { 1504 if (nCutEvent) 1505 Application::RemoveUserEvent(nCutEvent); 1506 nCutEvent = Application::PostUserEvent(LINK(this, OTableEditorCtrl, DelayedCut)); 1507 } 1508 } 1509 1510 //------------------------------------------------------------------------------ 1511 void OTableEditorCtrl::copy() 1512 { 1513 if(GetSelectRowCount()) 1514 OTableRowView::copy(); 1515 else if(m_eChildFocus == NAME) 1516 pNameCell->Copy(); 1517 else if(HELPTEXT == m_eChildFocus ) 1518 pHelpTextCell->Copy(); 1519 else if(m_eChildFocus == DESCRIPTION ) 1520 pDescrCell->Copy(); 1521 } 1522 1523 //------------------------------------------------------------------------------ 1524 void OTableEditorCtrl::paste() 1525 { 1526 TransferableDataHelper aTransferData(TransferableDataHelper::CreateFromSystemClipboard(GetParent())); 1527 if(aTransferData.HasFormat(SOT_FORMATSTR_ID_SBA_TABED)) 1528 { 1529 if( nPasteEvent ) 1530 Application::RemoveUserEvent( nPasteEvent ); 1531 nPasteEvent = Application::PostUserEvent( LINK(this, OTableEditorCtrl, DelayedPaste) ); 1532 } 1533 else if(m_eChildFocus == NAME) 1534 { 1535 if(GetView()->getController().isAlterAllowed()) 1536 { 1537 pNameCell->Paste(); 1538 CellModified(); 1539 } 1540 } 1541 else if(HELPTEXT == m_eChildFocus ) 1542 { 1543 if(GetView()->getController().isAlterAllowed()) 1544 { 1545 pHelpTextCell->Paste(); 1546 CellModified(); 1547 } 1548 } 1549 else if(m_eChildFocus == DESCRIPTION) 1550 { 1551 if(GetView()->getController().isAlterAllowed()) 1552 { 1553 pDescrCell->Paste(); 1554 CellModified(); 1555 } 1556 } 1557 } 1558 1559 //------------------------------------------------------------------------------ 1560 sal_Bool OTableEditorCtrl::IsDeleteAllowed( long /*nRow*/ ) 1561 { 1562 DBG_CHKTHIS(OTableEditorCtrl,NULL); 1563 1564 return GetSelectRowCount() != 0 && GetView()->getController().isDropAllowed(); 1565 } 1566 1567 //------------------------------------------------------------------------------ 1568 sal_Bool OTableEditorCtrl::IsInsertNewAllowed( long nRow ) 1569 { 1570 DBG_CHKTHIS(OTableEditorCtrl,NULL); 1571 1572 sal_Bool bInsertNewAllowed = GetView()->getController().isAddAllowed(); 1573 ////////////////////////////////////////////////////////////// 1574 // Wenn nur Felder hinzugefuegt werden duerfen, Paste nur in neue Felder 1575 if (bInsertNewAllowed && !GetView()->getController().isDropAllowed()) 1576 { 1577 SetDataPtr(nRow); 1578 if( GetActRow()->IsReadOnly() ) 1579 return sal_False; 1580 } 1581 1582 return bInsertNewAllowed; 1583 } 1584 1585 //------------------------------------------------------------------------------ 1586 sal_Bool OTableEditorCtrl::IsPrimaryKeyAllowed( long /*nRow*/ ) 1587 { 1588 DBG_CHKTHIS(OTableEditorCtrl,NULL); 1589 if( !GetSelectRowCount() ) 1590 return sal_False; 1591 1592 OTableController& rController = GetView()->getController(); 1593 if ( !rController.getSdbMetaData().supportsPrimaryKeys() ) 1594 return sal_False; 1595 1596 Reference<XPropertySet> xTable = rController.getTable(); 1597 ////////////////////////////////////////////////////////////// 1598 // Key darf nicht veraendert werden 1599 // Dies gilt jedoch nur, wenn die Tabelle nicht neu ist und keine ::com::sun::star::sdbcx::View. Ansonsten wird kein DROP ausgef�hrt 1600 1601 if(xTable.is() && ::comphelper::getString(xTable->getPropertyValue(PROPERTY_TYPE)) == ::rtl::OUString::createFromAscii("VIEW")) 1602 return sal_False; 1603 ////////////////////////////////////////////////////////////// 1604 // Wenn leeres Feld, kein PrimKey 1605 // Eintrag wird nur erlaubt, wenn 1606 // - kein leerer Eintrag in der Selection ist 1607 // - kein Eintrag vom Typ Memo oder Image ist 1608 // - kein DROP erlaubt ist (s.o.) und die Spalte noch kein Required (not null) gesetzt hatte. 1609 long nIndex = FirstSelectedRow(); 1610 ::boost::shared_ptr<OTableRow> pRow; 1611 while( nIndex >= 0 && nIndex < static_cast<long>(m_pRowList->size()) ) 1612 { 1613 pRow = (*m_pRowList)[nIndex]; 1614 OFieldDescription* pFieldDescr = pRow->GetActFieldDescr(); 1615 if(!pFieldDescr) 1616 return sal_False; 1617 else 1618 { 1619 ////////////////////////////////////////////////////////////// 1620 // Wenn Feldtyp Memo oder Image, kein PrimKey 1621 // oder wenn Spalten nicht gedroped werden k�nnen und das Required Flag ist nicht gesetzt 1622 // oder wenn eine ::com::sun::star::sdbcx::View vorhanden ist und das Required Flag nicht gesetzt ist 1623 TOTypeInfoSP pTypeInfo = pFieldDescr->getTypeInfo(); 1624 if( pTypeInfo->nSearchType == ColumnSearch::NONE 1625 || (pFieldDescr->IsNullable() && pRow->IsReadOnly()) 1626 ) 1627 return sal_False; 1628 } 1629 1630 nIndex = NextSelectedRow(); 1631 } 1632 1633 return sal_True; 1634 } 1635 1636 //------------------------------------------------------------------------------ 1637 void OTableEditorCtrl::Command(const CommandEvent& rEvt) 1638 { 1639 DBG_CHKTHIS(OTableEditorCtrl,NULL); 1640 switch (rEvt.GetCommand()) 1641 { 1642 case COMMAND_CONTEXTMENU: 1643 { 1644 Point aMenuPos( rEvt.GetMousePosPixel() ); 1645 if (!rEvt.IsMouseEvent()) 1646 { 1647 if ( 1 == GetSelectColumnCount() ) 1648 { 1649 sal_uInt16 nSelId = GetColumnId( 1650 sal::static_int_cast< sal_uInt16 >( 1651 FirstSelectedColumn() ) ); 1652 ::Rectangle aColRect( GetFieldRectPixel( 0, nSelId, sal_False ) ); 1653 1654 aMenuPos = aColRect.TopCenter(); 1655 } 1656 else if ( GetSelectRowCount() > 0 ) 1657 { 1658 ::Rectangle aColRect( GetFieldRectPixel( FirstSelectedRow(), HANDLE_ID, sal_True ) ); 1659 1660 aMenuPos = aColRect.TopCenter(); 1661 } 1662 else 1663 { 1664 OTableRowView::Command(rEvt); 1665 return; 1666 } 1667 } 1668 1669 ////////////////////////////////////////////////////////////// 1670 // Kontextmenu einblenden 1671 if( !IsReadOnly() ) 1672 { 1673 sal_uInt16 nColId = GetColumnAtXPosPixel(aMenuPos.X()); 1674 long nRow = GetRowAtYPosPixel(aMenuPos.Y()); 1675 1676 if ( HANDLE_ID != nColId ) 1677 { 1678 if ( nRow < 0 && nColId != BROWSER_INVALIDID ) 1679 { // hit the header 1680 if ( 3 != nColId ) 1681 { // 3 would mean the last column, and this last column is auto-sized 1682 if ( !IsColumnSelected( nColId ) ) 1683 SelectColumnId( nColId ); 1684 1685 PopupMenu aContextMenu( ModuleRes( RID_QUERYCOLPOPUPMENU ) ); 1686 aContextMenu.EnableItem( SID_DELETE, sal_False ); 1687 aContextMenu.RemoveDisabledEntries(sal_True, sal_True); 1688 switch ( aContextMenu.Execute( this, aMenuPos ) ) 1689 { 1690 case ID_BROWSER_COLWIDTH: 1691 adjustBrowseBoxColumnWidth( this, nColId ); 1692 break; 1693 } 1694 } 1695 } 1696 } 1697 else 1698 { 1699 PopupMenu aContextMenu(ModuleRes(RID_TABLEDESIGNROWPOPUPMENU)); 1700 1701 aContextMenu.EnableItem( SID_CUT, IsCutAllowed(nRow) ); 1702 aContextMenu.EnableItem( SID_COPY, IsCopyAllowed(nRow) ); 1703 aContextMenu.EnableItem( SID_PASTE, IsPasteAllowed(nRow) ); 1704 aContextMenu.EnableItem( SID_DELETE, IsDeleteAllowed(nRow) ); 1705 aContextMenu.EnableItem( SID_TABLEDESIGN_TABED_PRIMARYKEY, IsPrimaryKeyAllowed(nRow) ); 1706 aContextMenu.EnableItem( SID_TABLEDESIGN_INSERTROWS, IsInsertNewAllowed(nRow) ); 1707 aContextMenu.CheckItem( SID_TABLEDESIGN_TABED_PRIMARYKEY, IsRowSelected(GetCurRow()) && IsPrimaryKey() ); 1708 1709 // jetzt alles, was disabled wurde, wech 1710 aContextMenu.RemoveDisabledEntries(sal_True, sal_True); 1711 1712 if( SetDataPtr(m_nDataPos) ) 1713 pDescrWin->SaveData( pActRow->GetActFieldDescr() ); 1714 1715 ////////////////////////////////////////////////////////////// 1716 // Alle Aktionen, die die Zeilenzahl veraendern, muessen asynchron 1717 // ausgefuehrt werden->sonst Probleme zwischen Kontextmenu u. Browser 1718 m_nDataPos = GetCurRow(); 1719 switch (aContextMenu.Execute(this, aMenuPos)) 1720 { 1721 case SID_CUT: 1722 cut(); 1723 break; 1724 case SID_COPY: 1725 copy(); 1726 break; 1727 case SID_PASTE: 1728 paste(); 1729 break; 1730 case SID_DELETE: 1731 if( nDeleteEvent ) 1732 Application::RemoveUserEvent( nDeleteEvent ); 1733 nDeleteEvent = Application::PostUserEvent( LINK(this, OTableEditorCtrl, DelayedDelete) ); 1734 break; 1735 case SID_TABLEDESIGN_INSERTROWS: 1736 if( nInsNewRowsEvent ) 1737 Application::RemoveUserEvent( nInsNewRowsEvent ); 1738 nInsNewRowsEvent = Application::PostUserEvent( LINK(this, OTableEditorCtrl, DelayedInsNewRows) ); 1739 break; 1740 case SID_TABLEDESIGN_TABED_PRIMARYKEY: 1741 SetPrimaryKey( !IsPrimaryKey() ); 1742 break; 1743 default: 1744 break; 1745 } 1746 } 1747 } 1748 } 1749 break; 1750 default: 1751 OTableRowView::Command(rEvt); 1752 } 1753 1754 } 1755 1756 //------------------------------------------------------------------------------ 1757 IMPL_LINK( OTableEditorCtrl, DelayedCut, void*, /*EMPTYTAG*/ ) 1758 { 1759 nCutEvent = 0; 1760 OTableRowView::cut(); 1761 return 0; 1762 } 1763 1764 //------------------------------------------------------------------------------ 1765 IMPL_LINK( OTableEditorCtrl, DelayedPaste, void*, /*EMPTYTAG*/ ) 1766 { 1767 nPasteEvent = 0; 1768 1769 sal_Int32 nPastePosition = GetView()->getController().getFirstEmptyRowPosition(); 1770 if ( !GetView()->getController().getTable().is() ) 1771 nPastePosition = GetSelectRowCount() ? FirstSelectedRow() : GetCurRow(); 1772 1773 if (!IsInsertNewAllowed(nPastePosition)) 1774 { // kein Einfuegen erlaubt, sondern nur anhaengen, also testen, ob hinter der PastePosition noch 1775 // belegte Zeilen erscheinen 1776 1777 sal_Int32 nFreeFromPos; // ab da nur freie Zeilen 1778 ::std::vector< ::boost::shared_ptr<OTableRow> >::reverse_iterator aIter = m_pRowList->rbegin(); 1779 for(nFreeFromPos = m_pRowList->size(); 1780 aIter != m_pRowList->rend() && (!(*aIter) || !(*aIter)->GetActFieldDescr() || !(*aIter)->GetActFieldDescr()->GetName().getLength()); 1781 --nFreeFromPos, ++aIter) 1782 ; 1783 if (nPastePosition < nFreeFromPos) // es gibt mindestens eine belegte hinter PastePosition -> ganz nach hinten 1784 nPastePosition = nFreeFromPos; 1785 } 1786 1787 OTableRowView::Paste( nPastePosition ); 1788 SetNoSelection(); 1789 GoToRow( nPastePosition ); 1790 1791 return 0; 1792 } 1793 1794 //------------------------------------------------------------------------------ 1795 IMPL_LINK( OTableEditorCtrl, DelayedDelete, void*, /*EMPTYTAG*/ ) 1796 { 1797 nDeleteEvent = 0; 1798 DeleteRows(); 1799 return 0; 1800 } 1801 1802 //------------------------------------------------------------------------------ 1803 IMPL_LINK( OTableEditorCtrl, DelayedInsNewRows, void*, /*EMPTYTAG*/ ) 1804 { 1805 DBG_CHKTHIS(OTableEditorCtrl,NULL); 1806 nInsNewRowsEvent = 0; 1807 sal_Int32 nPastePosition = GetView()->getController().getFirstEmptyRowPosition(); 1808 if ( !GetView()->getController().getTable().is() ) 1809 nPastePosition = GetSelectRowCount() ? FirstSelectedRow() : m_nDataPos; 1810 1811 InsertNewRows( nPastePosition ); 1812 SetNoSelection(); 1813 GoToRow( nPastePosition ); 1814 1815 return 0; 1816 } 1817 // ----------------------------------------------------------------------------- 1818 void OTableEditorCtrl::AdjustFieldDescription(OFieldDescription* _pFieldDesc, 1819 MultiSelection& _rMultiSel, 1820 sal_Int32 _nPos, 1821 sal_Bool _bSet, 1822 sal_Bool _bPrimaryKey) 1823 { 1824 _pFieldDesc->SetPrimaryKey( _bPrimaryKey ); 1825 if(!_bSet && _pFieldDesc->getTypeInfo()->bNullable) 1826 { 1827 _pFieldDesc->SetIsNullable(ColumnValue::NO_NULLS); 1828 _pFieldDesc->SetControlDefault(Any()); 1829 } // if(!_bSet && _pFieldDesc->getTypeInfo()->bNullable) 1830 if ( _pFieldDesc->IsAutoIncrement() && !_bPrimaryKey ) 1831 { 1832 OTableController& rController = GetView()->getController(); 1833 if ( rController.isAutoIncrementPrimaryKey() ) 1834 { 1835 _pFieldDesc->SetAutoIncrement(false); 1836 } 1837 } 1838 ////////////////////////////////////////////////////////////////////// 1839 // update field description 1840 pDescrWin->DisplayData(_pFieldDesc); 1841 1842 _rMultiSel.Insert( _nPos ); 1843 _rMultiSel.Select( _nPos ); 1844 } 1845 //------------------------------------------------------------------------------ 1846 void OTableEditorCtrl::SetPrimaryKey( sal_Bool bSet ) 1847 { 1848 DBG_CHKTHIS(OTableEditorCtrl,NULL); 1849 ////////////////////////////////////////////////////////////////////// 1850 // Evtl. vorhandene Primary Keys loeschen 1851 MultiSelection aDeletedPrimKeys; 1852 aDeletedPrimKeys.SetTotalRange( Range(0,GetRowCount()) ); 1853 long nIndex = 0; 1854 1855 ::std::vector< ::boost::shared_ptr<OTableRow> >::const_iterator aIter = m_pRowList->begin(); 1856 ::std::vector< ::boost::shared_ptr<OTableRow> >::const_iterator aEnd = m_pRowList->end(); 1857 for(sal_Int32 nRow = 0;aIter != aEnd;++aIter,++nRow) 1858 { 1859 OFieldDescription* pFieldDescr = (*aIter)->GetActFieldDescr(); 1860 if( pFieldDescr && (*aIter)->IsPrimaryKey() && (!bSet || !IsRowSelected(nRow)) ) 1861 { 1862 AdjustFieldDescription(pFieldDescr,aDeletedPrimKeys,nRow,bSet,sal_False); 1863 } 1864 } 1865 1866 ////////////////////////////////////////////////////////////////////// 1867 // Die Primary Keys der markierten Zeilen setzen 1868 MultiSelection aInsertedPrimKeys; 1869 aInsertedPrimKeys.SetTotalRange( Range(0,GetRowCount()) ); 1870 if( bSet ) 1871 { 1872 nIndex = FirstSelectedRow(); 1873 while( nIndex >= 0 && nIndex < static_cast<long>(m_pRowList->size()) ) 1874 { 1875 ////////////////////////////////////////////////////////////////////// 1876 // Key setzen 1877 ::boost::shared_ptr<OTableRow> pRow = (*m_pRowList)[nIndex]; 1878 OFieldDescription* pFieldDescr = pRow->GetActFieldDescr(); 1879 if(pFieldDescr) 1880 AdjustFieldDescription(pFieldDescr,aInsertedPrimKeys,nIndex,sal_False,sal_True); 1881 1882 nIndex = NextSelectedRow(); 1883 } 1884 } 1885 1886 GetUndoManager().AddUndoAction( new OPrimKeyUndoAct(this, aDeletedPrimKeys, aInsertedPrimKeys) ); 1887 1888 ////////////////////////////////////////////////////////////////////// 1889 // Handle-Spalte invalidieren 1890 InvalidateHandleColumn(); 1891 1892 1893 ////////////////////////////////////////////////////////////////////// 1894 // Das ModifyFlag der TableDocSh setzen 1895 GetView()->getController().setModified( sal_True ); 1896 InvalidateFeatures(); 1897 } 1898 1899 //------------------------------------------------------------------------------ 1900 sal_Bool OTableEditorCtrl::IsPrimaryKey() 1901 { 1902 DBG_CHKTHIS(OTableEditorCtrl,NULL); 1903 ////////////////////////////////////////////////////////////////////// 1904 // Gehoeren alle markierten Felder zu einem Primary Key ? 1905 long nPrimaryKeys = 0; 1906 ::std::vector< ::boost::shared_ptr<OTableRow> >::const_iterator aIter = m_pRowList->begin(); 1907 ::std::vector< ::boost::shared_ptr<OTableRow> >::const_iterator aEnd = m_pRowList->end(); 1908 for(sal_Int32 nRow=0;aIter != aEnd;++aIter,++nRow) 1909 { 1910 if( IsRowSelected(nRow) && !(*aIter)->IsPrimaryKey() ) 1911 return sal_False; 1912 if( (*aIter)->IsPrimaryKey() ) 1913 ++nPrimaryKeys; 1914 } 1915 1916 ////////////////////////////////////////////////////////////////////// 1917 // Gibt es unselektierte Felder, die noch zu dem Key gehoeren ? 1918 return GetSelectRowCount() == nPrimaryKeys; 1919 } 1920 1921 //------------------------------------------------------------------------------ 1922 void OTableEditorCtrl::SwitchType( const TOTypeInfoSP& _pType ) 1923 { 1924 DBG_CHKTHIS(OTableEditorCtrl,NULL); 1925 ////////////////////////////////////////////////////////////////////// 1926 // Wenn noch kein Feldname vergeben wurde 1927 long nRow(GetCurRow()); 1928 OFieldDescription* pActFieldDescr = GetFieldDescr( nRow ); 1929 if( pActFieldDescr ) 1930 ////////////////////////////////////////////////////////////////////// 1931 // Alte Beschreibung speichern 1932 pDescrWin->SaveData( pActFieldDescr ); 1933 1934 if ( nRow < 0 || nRow > static_cast<long>(m_pRowList->size()) ) 1935 return; 1936 ////////////////////////////////////////////////////////////////////// 1937 // Neue Beschreibung darstellen 1938 ::boost::shared_ptr<OTableRow> pRow = (*m_pRowList)[nRow]; 1939 pRow->SetFieldType( _pType, sal_True ); 1940 if ( _pType.get() ) 1941 { 1942 const sal_uInt16 nCurrentlySelected = pTypeCell->GetSelectEntryPos(); 1943 1944 if ( ( LISTBOX_ENTRY_NOTFOUND == nCurrentlySelected ) 1945 || ( GetView()->getController().getTypeInfo( nCurrentlySelected ) != _pType ) 1946 ) 1947 { 1948 sal_uInt16 nEntryPos = 0; 1949 const OTypeInfoMap* pTypeInfo = GetView()->getController().getTypeInfo(); 1950 OTypeInfoMap::const_iterator aIter = pTypeInfo->begin(); 1951 OTypeInfoMap::const_iterator aEnd = pTypeInfo->end(); 1952 for(;aIter != aEnd;++aIter,++nEntryPos) 1953 { 1954 if(aIter->second == _pType) 1955 break; 1956 } 1957 if (nEntryPos < pTypeCell->GetEntryCount()) 1958 pTypeCell->SelectEntryPos( nEntryPos ); 1959 } 1960 } 1961 1962 pActFieldDescr = pRow->GetActFieldDescr(); 1963 if (pActFieldDescr != NULL && !pActFieldDescr->GetFormatKey()) 1964 { 1965 sal_Int32 nFormatKey = ::dbtools::getDefaultNumberFormat( pActFieldDescr->GetType(), 1966 pActFieldDescr->GetScale(), 1967 pActFieldDescr->IsCurrency(), 1968 Reference< XNumberFormatTypes>(GetView()->getController().getNumberFormatter()->getNumberFormatsSupplier()->getNumberFormats(),UNO_QUERY), 1969 GetView()->getLocale()); 1970 1971 pActFieldDescr->SetFormatKey(nFormatKey); 1972 } 1973 1974 pDescrWin->DisplayData( pActFieldDescr ); 1975 } 1976 // ----------------------------------------------------------------------------- 1977 OTableDesignView* OTableEditorCtrl::GetView() const 1978 { 1979 return static_cast<OTableDesignView*>(GetParent()->GetParent()); 1980 } 1981 // ----------------------------------------------------------------------------- 1982 void OTableEditorCtrl::DeactivateCell(sal_Bool bUpdate) 1983 { 1984 OTableRowView::DeactivateCell(bUpdate); 1985 // now we have to deactivate the field description 1986 long nRow(GetCurRow()); 1987 if (pDescrWin) 1988 pDescrWin->SetReadOnly(bReadOnly || !SetDataPtr(nRow) || GetActRow()->IsReadOnly()); 1989 } 1990 //------------------------------------------------------------------------------ 1991 long OTableEditorCtrl::PreNotify( NotifyEvent& rNEvt ) 1992 { 1993 if (rNEvt.GetType() == EVENT_GETFOCUS) 1994 { 1995 if( pHelpTextCell && pHelpTextCell->HasChildPathFocus() ) 1996 m_eChildFocus = HELPTEXT; 1997 else if( pDescrCell && pDescrCell->HasChildPathFocus() ) 1998 m_eChildFocus = DESCRIPTION; 1999 else if(pNameCell && pNameCell->HasChildPathFocus() ) 2000 m_eChildFocus = NAME; 2001 else 2002 m_eChildFocus = ROW; 2003 } 2004 2005 return OTableRowView::PreNotify(rNEvt); 2006 } 2007 // ----------------------------------------------------------------------------- 2008 2009 2010 2011 2012