xref: /trunk/main/extensions/source/bibliography/datman.cxx (revision 2a97ec55f1442d65917e8c8b82a55ab76c9ff676)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_extensions.hxx"
#include <osl/mutex.hxx>
#include <tools/diagnose_ex.h>
#include <tools/urlobj.hxx>
#include <comphelper/processfactory.hxx>
#include <com/sun/star/io/XPersistObject.hpp>
#include <com/sun/star/sdbc/ResultSetType.hpp>
#include <com/sun/star/sdbc/ResultSetConcurrency.hpp>
#include <com/sun/star/sdbc/XResultSetUpdate.hpp>
#include <com/sun/star/sdbcx/XRowLocate.hpp>
#include <com/sun/star/sdbc/DataType.hpp>
#include <com/sun/star/sdb/XSingleSelectQueryComposer.hpp>
#include <com/sun/star/sdbc/XDatabaseMetaData.hpp>
#include <com/sun/star/sdb/XDatabaseEnvironment.hpp>
#include <com/sun/star/uno/XNamingService.hpp>
#include <com/sun/star/sdbc/XDataSource.hpp>
#include <com/sun/star/sdb/CommandType.hpp>
#include <com/sun/star/sdbcx/XTablesSupplier.hpp>
#include <com/sun/star/sdbc/XConnection.hpp>
#include <com/sun/star/sdb/XCompletedConnection.hpp>
#include <com/sun/star/task/XInteractionHandler.hpp>
#include <com/sun/star/form/XLoadable.hpp>
#include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
#include <com/sun/star/form/XGridColumnFactory.hpp>
#include <com/sun/star/io/XDataInputStream.hpp>
#include <com/sun/star/container/XNameContainer.hpp>
#include <com/sun/star/ucb/XContentProvider.hpp>
#include <com/sun/star/ucb/XContentAccess.hpp>
#include <ucbhelper/contentbroker.hxx>
#include <ucbhelper/content.hxx>
#include <ucbhelper/contentidentifier.hxx>
#include <comphelper/container.hxx>
#include <svl/urihelper.hxx>
#include <svtools/svtabbx.hxx>
#include <svtools/headbar.hxx>
#include <vcl/dialog.hxx>
#ifndef _SV_BUTTON_HXX
#include <vcl/button.hxx>
#endif
#include <vcl/lstbox.hxx>
#include <vcl/fixed.hxx>
#include <vcl/group.hxx>
#include <vcl/lstbox.hxx>
#include <vcl/edit.hxx>
#include <vcl/msgbox.hxx>
#include <tools/debug.hxx>
#include "datman.hxx"
#include "bibresid.hxx"
#include "bibmod.hxx"
#include "bibview.hxx"
// #100312# ---------
#include "bibbeam.hxx"
#include "bibprop.hrc"
#include "toolbar.hxx"
#include "toolbar.hrc"
#include "bibconfig.hxx"
#include "bibbeam.hxx"
#include "bib.hrc"
#include "datman.hrc"
#include "bibliography.hrc"
#include <connectivity/dbtools.hxx>

using namespace ::com::sun::star;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::container;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::sdb;
using namespace ::com::sun::star::sdbc;
using namespace ::com::sun::star::sdbcx;
using namespace ::com::sun::star::form;
using namespace ::com::sun::star::frame;
using namespace ::com::sun::star::ucb;
using namespace ::com::sun::star::lang;
using namespace ::ucb;

#define C2U(cChar) ::rtl::OUString::createFromAscii(cChar)
#define C2S(cChar) String::CreateFromAscii(cChar)
#define MAP_TOKEN ';'
#define PAIR_TOKEN ':'


/* -----------------17.01.00 14:38-------------------

 --------------------------------------------------*/
Reference< XConnection > getConnection(const ::rtl::OUString& _rURL)
{
    // first get the sdb::DataSource corresponding to the url
    Reference< XDataSource >    xDataSource;
    // is it a favorite title ?
    Reference< XMultiServiceFactory >  xMgr = comphelper::getProcessServiceFactory();
    Reference<XInterface> xNamingContextIfc = xMgr->createInstance(C2U("com.sun.star.sdb.DatabaseContext"));
    Reference< XNameAccess >  xNamingContext(xNamingContextIfc, UNO_QUERY);
    if (xNamingContext.is() && xNamingContext->hasByName(_rURL))
    {
        DBG_ASSERT(Reference< XNamingService > (xNamingContext, UNO_QUERY).is(), "::getDataSource : no NamingService interface on the sdb::DatabaseAccessContext !");
        try
        {
            xDataSource = Reference< XDataSource > (Reference< XNamingService > (xNamingContext, UNO_QUERY)->getRegisteredObject(_rURL), UNO_QUERY);
        }
        catch(Exception eEx)
        {
            (void) eEx; // make compiler happy
            DBG_ERROR("Exception caught in ODatabaseContext::getRegisteredObject()");
        }
    }
    // build the connection from the data source
    Reference< XConnection >    xConn;
    if (xDataSource.is())
    {
        // need user/pwd for this
        ::rtl::OUString sUser, sPwd;
        Reference< XPropertySet >  xDataSourceProps(xDataSource, UNO_QUERY);
        Reference< XCompletedConnection > xComplConn(xDataSource, UNO_QUERY);
/*      Reference< XPropertySetInfo >  xInfo = xDataSourceProps.is() ? xDataSourceProps->getPropertySetInfo() : Reference< XPropertySetInfo > ();
        if (xInfo.is() && xInfo->hasPropertyByName(C2U("User")))
            xDataSourceProps->getPropertyValue(C2U("User")) >>= sUser;
        if (xInfo.is() && xInfo->hasPropertyByName(C2U("Password")))
            xDataSourceProps->getPropertyValue(C2U("Password"))>>= sPwd;
*/
        try
        {

            Reference<XInterface> xHdl = xMgr->createInstance(C2U("com.sun.star.task.InteractionHandler"));
            Reference<task::XInteractionHandler> xIHdl(xHdl, UNO_QUERY);
            xConn = xComplConn->connectWithCompletion(xIHdl);
//          xConn = xDataSource->getConnection(sUser, sPwd);
        }
        catch(SQLException&)
        {
            // TODO : a real error handling
        }
        catch(Exception& e )
        {
            (void) e;   // make compiler happy
        }

    }
    return xConn;
}

/* -----------------17.01.00 14:46-------------------

 --------------------------------------------------*/
Reference< XConnection >    getConnection(const Reference< XInterface > & xRowSet)
{
    Reference< XConnection >    xConn;
    try
    {
        Reference< XPropertySet >  xFormProps(xRowSet, UNO_QUERY);
        if (!xFormProps.is())
            return xConn;

        xConn = Reference< XConnection > (*(Reference< XInterface > *)xFormProps->getPropertyValue(C2U("ActiveConnection")).getValue(), UNO_QUERY);
        if (!xConn.is())
        {
            DBG_WARNING("no active connection");
        }
    }
    catch(Exception& e )
    {
        (void) e;   // make compiler happy
        DBG_ERROR("exception in getConnection");
    }

    return xConn;
}
/* -----------------17.01.00 16:07-------------------

 --------------------------------------------------*/
Reference< XNameAccess >  getColumns(const Reference< XForm > & _rxForm)
{
    Reference< XNameAccess >  xReturn;
    // check if the form is alive
    Reference< XColumnsSupplier >  xSupplyCols( _rxForm, UNO_QUERY );
    if (xSupplyCols.is())
        xReturn = xSupplyCols->getColumns();

    if (!xReturn.is() || (xReturn->getElementNames().getLength() == 0))
    {   // no ....
        xReturn = NULL;
        // -> get the table the form is bound to and ask it for their columns
        Reference< XTablesSupplier >  xSupplyTables( getConnection( _rxForm ), UNO_QUERY );
        Reference< XPropertySet >  xFormProps( _rxForm, UNO_QUERY );
        if (xFormProps.is() && xSupplyTables.is())
        {
            try
            {
                DBG_ASSERT((*(sal_Int32*)xFormProps->getPropertyValue(C2U("CommandType")).getValue()) == CommandType::TABLE,
                    "::getColumns : invalid form (has no table as data source) !");
                ::rtl::OUString sTable;
                xFormProps->getPropertyValue(C2U("Command")) >>= sTable;
                Reference< XNameAccess >  xTables = xSupplyTables->getTables();
                if (xTables.is() && xTables->hasByName(sTable))
                    xSupplyCols = Reference< XColumnsSupplier > (
                        *(Reference< XInterface > *)xTables->getByName(sTable).getValue(), UNO_QUERY);
                if (xSupplyCols.is())
                    xReturn = xSupplyCols->getColumns();
            }
#ifdef DBG_UTIL
            catch(Exception& e )
#else
            catch(Exception&)
#endif
            {
#ifdef DBG_UTIL
                String sMsg(String::CreateFromAscii("::getColumns : catched an exception ("));
                sMsg += String(e.Message);
                sMsg.AppendAscii(") ...");
                DBG_ERROR( ByteString(sMsg, RTL_TEXTENCODING_ASCII_US ).GetBuffer());
#endif
            }

        }
    }
    return xReturn;
}

/* -----------------11.11.99 15:54-------------------

 --------------------------------------------------*/
class MappingDialog_Impl : public ModalDialog
{
    BibDataManager* pDatMan;
    OKButton        aOKBT;
    CancelButton    aCancelBT;
    HelpButton      aHelpBT;
    FixedLine       aMapGB;
    FixedText       aIdentifierFT;
    ListBox         aIdentifierLB;
    FixedText       aAuthorityTypeFT;
    ListBox         aAuthorityTypeLB;
    FixedText       aAuthorFT;
    ListBox         aAuthorLB;
    FixedText       aTitleFT;
    ListBox         aTitleLB;
    FixedText       aMonthFT;
    ListBox         aMonthLB;
    FixedText       aYearFT;
    ListBox         aYearLB;
    FixedText       aISBNFT;
    ListBox         aISBNLB;
    FixedText       aBooktitleFT;
    ListBox         aBooktitleLB;
    FixedText       aChapterFT;
    ListBox         aChapterLB;
    FixedText       aEditionFT;
    ListBox         aEditionLB;
    FixedText       aEditorFT;
    ListBox         aEditorLB;
    FixedText       aHowpublishedFT;
    ListBox         aHowpublishedLB;
    FixedText       aInstitutionFT;
    ListBox         aInstitutionLB;
    FixedText       aJournalFT;
    ListBox         aJournalLB;
    FixedText       aNoteFT;
    ListBox         aNoteLB;
    FixedText       aAnnoteFT;
    ListBox         aAnnoteLB;
    FixedText       aNumberFT;
    ListBox         aNumberLB;
    FixedText       aOrganizationsFT;
    ListBox         aOrganizationsLB;
    FixedText       aPagesFT;
    ListBox         aPagesLB;
    FixedText       aPublisherFT;
    ListBox         aPublisherLB;
    FixedText       aAddressFT;
    ListBox         aAddressLB;
    FixedText       aSchoolFT;
    ListBox         aSchoolLB;
    FixedText       aSeriesFT;
    ListBox         aSeriesLB;
    FixedText       aReportTypeFT;
    ListBox         aReportTypeLB;
    FixedText       aVolumeFT;
    ListBox         aVolumeLB;
    FixedText       aURLFT;
    ListBox         aURLLB;
    FixedText       aCustom1FT;
    ListBox         aCustom1LB;
    FixedText       aCustom2FT;
    ListBox         aCustom2LB;
    FixedText       aCustom3FT;
    ListBox         aCustom3LB;
    FixedText       aCustom4FT;
    ListBox         aCustom4LB;
    FixedText       aCustom5FT;
    ListBox         aCustom5LB;
    ListBox*        aListBoxes[COLUMN_COUNT];
    String          sNone;

    sal_Bool        bModified;



    DECL_LINK(OkHdl, OKButton*);
    DECL_LINK(ListBoxSelectHdl, ListBox*);

public:
    MappingDialog_Impl(Window* pParent, BibDataManager* pDatMan);
    ~MappingDialog_Impl();

    void    SetModified() {bModified = sal_True;}

};
/* -----------------11.11.99 16:42-------------------

 --------------------------------------------------*/
sal_uInt16 lcl_FindLogicalName(BibConfig* pConfig ,
                                    const ::rtl::OUString& rLogicalColumnName)
{
    for(sal_uInt16 i = 0; i < COLUMN_COUNT; i++)
    {
        if(rLogicalColumnName == pConfig->GetDefColumnName(i))
            return i;
    }
    return USHRT_MAX;
}
//-----------------------------------------------------------------------------
MappingDialog_Impl::MappingDialog_Impl(Window* pParent, BibDataManager* pMan) :
    ModalDialog(pParent, BibResId(RID_DLG_MAPPING) ),
    pDatMan(pMan),
    aOKBT(this,                 BibResId( BT_OK         )),
    aCancelBT(this,             BibResId( BT_CANCEL     )),
    aHelpBT(this,               BibResId( BT_HELP           )),

    aMapGB(this,                BibResId( GB_MAPPING        )),

    aIdentifierFT(this,         BibResId( FT_IDENTIFIER )),
    aIdentifierLB(this,         BibResId( LB_IDENTIFIER )),
    aAuthorityTypeFT(this,      BibResId( FT_AUTHORITYTYPE )),
    aAuthorityTypeLB(this,      BibResId( LB_AUTHORITYTYPE )),
    aAuthorFT(this,             BibResId( FT_AUTHOR     )),
    aAuthorLB(this,             BibResId( LB_AUTHOR     )),
    aTitleFT(this,              BibResId( FT_TITLE      )),
    aTitleLB(this,              BibResId( LB_TITLE      )),
    aMonthFT(this,              BibResId( FT_MONTH      )),
    aMonthLB(this,              BibResId( LB_MONTH      )),
    aYearFT(this,               BibResId( FT_YEAR           )),
    aYearLB(this,               BibResId( LB_YEAR           )),
    aISBNFT(this,               BibResId( FT_ISBN           )),
    aISBNLB(this,               BibResId( LB_ISBN           )),
    aBooktitleFT(this,          BibResId( FT_BOOKTITLE  )),
    aBooktitleLB(this,          BibResId( LB_BOOKTITLE  )),
    aChapterFT(this,            BibResId( FT_CHAPTER        )),
    aChapterLB(this,            BibResId( LB_CHAPTER        )),
    aEditionFT(this,            BibResId( FT_EDITION        )),
    aEditionLB(this,            BibResId( LB_EDITION        )),
    aEditorFT(this,             BibResId( FT_EDITOR     )),
    aEditorLB(this,             BibResId( LB_EDITOR     )),
    aHowpublishedFT(this,       BibResId( FT_HOWPUBLISHED   )),
    aHowpublishedLB(this,       BibResId( LB_HOWPUBLISHED   )),
    aInstitutionFT(this,        BibResId( FT_INSTITUTION    )),
    aInstitutionLB(this,        BibResId( LB_INSTITUTION    )),
    aJournalFT(this,            BibResId( FT_JOURNAL        )),
    aJournalLB(this,            BibResId( LB_JOURNAL        )),
    aNoteFT(this,               BibResId( FT_NOTE           )),
    aNoteLB(this,               BibResId( LB_NOTE           )),
    aAnnoteFT(this,             BibResId( FT_ANNOTE     )),
    aAnnoteLB(this,             BibResId( LB_ANNOTE     )),
    aNumberFT(this,             BibResId( FT_NUMBER     )),
    aNumberLB(this,             BibResId( LB_NUMBER     )),
    aOrganizationsFT(this,      BibResId( FT_ORGANIZATIONS )),
    aOrganizationsLB(this,      BibResId( LB_ORGANIZATIONS )),
    aPagesFT(this,              BibResId( FT_PAGES      )),
    aPagesLB(this,              BibResId( LB_PAGES      )),
    aPublisherFT(this,          BibResId( FT_PUBLISHER  )),
    aPublisherLB(this,          BibResId( LB_PUBLISHER  )),
    aAddressFT(this,            BibResId( FT_ADDRESS        )),
    aAddressLB(this,            BibResId( LB_ADDRESS        )),
    aSchoolFT(this,             BibResId( FT_SCHOOL     )),
    aSchoolLB(this,             BibResId( LB_SCHOOL     )),
    aSeriesFT(this,             BibResId( FT_SERIES     )),
    aSeriesLB(this,             BibResId( LB_SERIES     )),
    aReportTypeFT(this,         BibResId( FT_REPORTTYPE )),
    aReportTypeLB(this,         BibResId( LB_REPORTTYPE )),
    aVolumeFT(this,             BibResId( FT_VOLUME     )),
    aVolumeLB(this,             BibResId( LB_VOLUME     )),
    aURLFT(this,                BibResId( FT_URL            )),
    aURLLB(this,                BibResId( LB_URL            )),
    aCustom1FT(this,            BibResId( FT_CUSTOM1        )),
    aCustom1LB(this,            BibResId( LB_CUSTOM1        )),
    aCustom2FT(this,            BibResId( FT_CUSTOM2        )),
    aCustom2LB(this,            BibResId( LB_CUSTOM2        )),
    aCustom3FT(this,            BibResId( FT_CUSTOM3        )),
    aCustom3LB(this,            BibResId( LB_CUSTOM3        )),
    aCustom4FT(this,            BibResId( FT_CUSTOM4        )),
    aCustom4LB(this,            BibResId( LB_CUSTOM4        )),
    aCustom5FT(this,            BibResId( FT_CUSTOM5        )),
    aCustom5LB(this,            BibResId( LB_CUSTOM5        )),
    sNone(BibResId(ST_NONE)),
    bModified(sal_False)
{
    FreeResource();

    aIdentifierFT.SetText(String(         BibResId( ST_IDENTIFIER    )));
    aAuthorityTypeFT.SetText(String(      BibResId( ST_AUTHTYPE )));
    aAuthorFT.SetText(String(             BibResId( ST_AUTHOR        )));
    aTitleFT.SetText(String(              BibResId( ST_TITLE         )));
    aMonthFT.SetText(String(              BibResId( ST_MONTH         )));
    aYearFT.SetText(String(               BibResId( ST_YEAR          )));
    aISBNFT.SetText(String(               BibResId( ST_ISBN          )));
    aBooktitleFT.SetText(String(          BibResId( ST_BOOKTITLE     )));
    aChapterFT.SetText(String(            BibResId( ST_CHAPTER       )));
    aEditionFT.SetText(String(            BibResId( ST_EDITION       )));
    aEditorFT.SetText(String(             BibResId( ST_EDITOR        )));
    aHowpublishedFT.SetText(String(       BibResId( ST_HOWPUBLISHED  )));
    aInstitutionFT.SetText(String(        BibResId( ST_INSTITUTION   )));
    aJournalFT.SetText(String(            BibResId( ST_JOURNAL       )));
    aNoteFT.SetText(String(               BibResId( ST_NOTE          )));
    aAnnoteFT.SetText(String(             BibResId( ST_ANNOTE        )));
    aNumberFT.SetText(String(             BibResId( ST_NUMBER        )));
    aOrganizationsFT.SetText(String(      BibResId( ST_ORGANIZATION )));
    aPagesFT.SetText(String(              BibResId( ST_PAGE         )));
    aPublisherFT.SetText(String(          BibResId( ST_PUBLISHER     )));
    aAddressFT.SetText(String(            BibResId( ST_ADDRESS       )));
    aSchoolFT.SetText(String(             BibResId( ST_SCHOOL        )));
    aSeriesFT.SetText(String(             BibResId( ST_SERIES        )));
    aReportTypeFT.SetText(String(         BibResId( ST_REPORT    )));
    aVolumeFT.SetText(String(             BibResId( ST_VOLUME        )));
    aURLFT.SetText(String(                BibResId( ST_URL           )));
    aCustom1FT.SetText(String(            BibResId( ST_CUSTOM1       )));
    aCustom2FT.SetText(String(            BibResId( ST_CUSTOM2       )));
    aCustom3FT.SetText(String(            BibResId( ST_CUSTOM3       )));
    aCustom4FT.SetText(String(            BibResId( ST_CUSTOM4       )));
    aCustom5FT.SetText(String(            BibResId( ST_CUSTOM5       )));

    aOKBT.SetClickHdl(LINK(this, MappingDialog_Impl, OkHdl));
    String sTitle = GetText();
    sTitle.SearchAndReplace(C2S("%1"), pDatMan->getActiveDataTable(), 0);
    SetText(sTitle);

    aListBoxes[0] = &aIdentifierLB;
    aListBoxes[1] = &aAuthorityTypeLB;
    aListBoxes[2] = &aAuthorLB;
    aListBoxes[3] = &aTitleLB;
    aListBoxes[4] = &aYearLB;
    aListBoxes[5] = &aISBNLB;
    aListBoxes[6] = &aBooktitleLB;
    aListBoxes[7] = &aChapterLB;
    aListBoxes[8] = &aEditionLB;
    aListBoxes[9] = &aEditorLB;
    aListBoxes[10] = &aHowpublishedLB;
    aListBoxes[11] = &aInstitutionLB;
    aListBoxes[12] = &aJournalLB;
    aListBoxes[13] = &aMonthLB;
    aListBoxes[14] = &aNoteLB;
    aListBoxes[15] = &aAnnoteLB;
    aListBoxes[16] = &aNumberLB;
    aListBoxes[17] = &aOrganizationsLB;
    aListBoxes[18] = &aPagesLB;
    aListBoxes[19] = &aPublisherLB;
    aListBoxes[20] = &aAddressLB;
    aListBoxes[21] = &aSchoolLB;
    aListBoxes[22] = &aSeriesLB;
    aListBoxes[23] = &aReportTypeLB;
    aListBoxes[24] = &aVolumeLB;
    aListBoxes[25] = &aURLLB;
    aListBoxes[26] = &aCustom1LB;
    aListBoxes[27] = &aCustom2LB;
    aListBoxes[28] = &aCustom3LB;
    aListBoxes[29] = &aCustom4LB;
    aListBoxes[30] = &aCustom5LB;

    aListBoxes[0]->InsertEntry(sNone);
    Reference< XNameAccess >  xFields = getColumns( pDatMan->getForm() );
    DBG_ASSERT(xFields.is(), "MappingDialog_Impl::MappingDialog_Impl : gave me an invalid form !");
    if(xFields.is())
    {
        Sequence< ::rtl::OUString > aNames = xFields->getElementNames();
        sal_Int32 nFieldsCount = aNames.getLength();
        const ::rtl::OUString* pNames = aNames.getConstArray();

        for(sal_Int32 nField = 0; nField < nFieldsCount; nField++)
            aListBoxes[0]->InsertEntry(pNames[nField]);
    }

    Link aLnk = LINK(this, MappingDialog_Impl, ListBoxSelectHdl);

    aListBoxes[0]->SelectEntryPos(0);
    aListBoxes[0]->SetSelectHdl(aLnk);
    for(sal_uInt16 i = 1; i < COLUMN_COUNT; i++)
    {
        for(sal_uInt16 j = 0; j < aListBoxes[0]->GetEntryCount();j++)
            aListBoxes[i]->InsertEntry(aListBoxes[0]->GetEntry(j));
        aListBoxes[i]->SelectEntryPos(0);
        aListBoxes[i]->SetSelectHdl(aLnk);
    }
    BibConfig* pConfig = BibModul::GetConfig();
    BibDBDescriptor aDesc;
    aDesc.sDataSource = pDatMan->getActiveDataSource();
    aDesc.sTableOrQuery = pDatMan->getActiveDataTable();
    aDesc.nCommandType = CommandType::TABLE;
    const Mapping* pMapping = pConfig->GetMapping(aDesc);
    if(pMapping)
    {
        for(sal_uInt16 nEntry = 0; nEntry < COLUMN_COUNT; nEntry++)
        {
            sal_uInt16 nListBoxIndex = lcl_FindLogicalName( pConfig, pMapping->aColumnPairs[nEntry].sLogicalColumnName);
            if(nListBoxIndex < COLUMN_COUNT)
            {
                aListBoxes[nListBoxIndex]->SelectEntry(pMapping->aColumnPairs[nEntry].sRealColumnName);
            }
        }
    }
}
/* -----------------11.11.99 16:44-------------------

 --------------------------------------------------*/
MappingDialog_Impl::~MappingDialog_Impl()
{}
/* -----------------15.11.99 10:38-------------------

 --------------------------------------------------*/
IMPL_LINK(MappingDialog_Impl, ListBoxSelectHdl, ListBox*, pListBox)
{
    sal_uInt16 nEntryPos = pListBox->GetSelectEntryPos();
    if(0 < nEntryPos)
    {
        for(sal_uInt16 i = 0; i < COLUMN_COUNT; i++)
        {
            if(pListBox != aListBoxes[i] && aListBoxes[i]->GetSelectEntryPos() == nEntryPos)
                aListBoxes[i]->SelectEntryPos(0);
        }
    }
    SetModified();
    return 0;
}
/* -----------------12.11.99 14:50-------------------

 --------------------------------------------------*/
IMPL_LINK(MappingDialog_Impl, OkHdl, OKButton*, EMPTYARG)
{
    if(bModified)
    {
        Mapping aNew;
        aNew.sTableName = String(pDatMan->getActiveDataTable());
        aNew.sURL = String(pDatMan->getActiveDataSource());

        sal_uInt16 nWriteIndex = 0;
        BibConfig* pConfig = BibModul::GetConfig();
        for(sal_uInt16 nEntry = 0; nEntry < COLUMN_COUNT; nEntry++)
        {
            String sSel = aListBoxes[nEntry]->GetSelectEntry();
            if(sSel != sNone)
            {
                aNew.aColumnPairs[nWriteIndex].sRealColumnName = sSel;
                aNew.aColumnPairs[nWriteIndex].sLogicalColumnName = pConfig->GetDefColumnName(nEntry);
                nWriteIndex++;
            }
        }
        BibDBDescriptor aDesc;
        aDesc.sDataSource = pDatMan->getActiveDataSource();
        aDesc.sTableOrQuery = pDatMan->getActiveDataTable();
        aDesc.nCommandType = CommandType::TABLE;
        pDatMan->ResetIdentifierMapping();
        pConfig->SetMapping(aDesc, &aNew);
    }
    EndDialog(bModified ? RET_OK : RET_CANCEL);
    return 0;
}
/* -----------------18.11.99 10:23-------------------

 --------------------------------------------------*/
class DBChangeDialog_Impl : public ModalDialog
{
    OKButton        aOKBT;
    CancelButton    aCancelBT;
    HelpButton      aHelpBT;
    FixedLine       aSelectionGB;
    SvTabListBox    aSelectionLB;
    HeaderBar       aSelectionHB;
    DBChangeDialogConfig_Impl   aConfig;
    String          aEntryST;
    String          aURLST;

    BibDataManager* pDatMan;

//  DECL_LINK(EndDragHdl, HeaderBar*);
    DECL_LINK(DoubleClickHdl, SvTabListBox*);
public:
    DBChangeDialog_Impl(Window* pParent, BibDataManager* pMan );
    ~DBChangeDialog_Impl();

    String      GetCurrentURL()const;
};

/*-- 18.11.99 10:35:20---------------------------------------------------

  -----------------------------------------------------------------------*/
DBChangeDialog_Impl::DBChangeDialog_Impl(Window* pParent, BibDataManager* pMan ) :
    ModalDialog(pParent, BibResId(RID_DLG_DBCHANGE) ),
    aOKBT(this,         BibResId( BT_OK     )),
    aCancelBT(this,     BibResId( BT_CANCEL )),
    aHelpBT(this,       BibResId( BT_HELP       )),
    aSelectionGB(this,  BibResId( GB_SELECTION )),
    aSelectionLB(this,  BibResId( LB_SELECTION )),
    aSelectionHB(this,  BibResId( HB_SELECTION )),
    aEntryST(BibResId(ST_ENTRY)),
    aURLST( BibResId(ST_URL)),
    pDatMan(pMan)
{
    FreeResource();
    aSelectionLB.SetDoubleClickHdl( LINK(this, DBChangeDialog_Impl, DoubleClickHdl));
    try
    {
        Reference< XMultiServiceFactory >  xMgr = comphelper::getProcessServiceFactory();

        ::Size aSize = aSelectionHB.GetSizePixel();
        long nTabs[2];
        nTabs[0] = 1;// Number of Tabs
        nTabs[1] = aSize.Width() / 4;

        aSelectionHB.SetStyle(aSelectionHB.GetStyle()|WB_STDHEADERBAR);
        aSelectionHB.InsertItem( 1, aEntryST, aSize.Width());
        aSelectionHB.SetSizePixel(aSelectionHB.CalcWindowSizePixel());
        aSelectionHB.Show();

        aSelectionLB.SetTabs( &nTabs[0], MAP_PIXEL );
        aSelectionLB.SetStyle(aSelectionLB.GetStyle()|WB_CLIPCHILDREN|WB_SORT);
        aSelectionLB.GetModel()->SetSortMode(SortAscending);

        ::rtl::OUString sActiveSource = pDatMan->getActiveDataSource();
        const Sequence< ::rtl::OUString >& rSources = aConfig.GetDataSourceNames();
        const ::rtl::OUString* pSourceNames = rSources.getConstArray();
        for(int i = 0; i < rSources.getLength(); i++)
        {
            SvLBoxEntry* pEntry = aSelectionLB.InsertEntry(pSourceNames[i]);
            if(pSourceNames[i] == sActiveSource)
            {
                aSelectionLB.Select(pEntry);
            }
        }
        aSelectionLB.GetModel()->Resort();
    }
    catch(Exception& e )
    {
        (void) e;   // make compiler happy
        DBG_ERROR("Exception in BibDataManager::DBChangeDialog_Impl::DBChangeDialog_Impl");
    }


}
/* -----------------06.12.99 12:09-------------------

 --------------------------------------------------*/
IMPL_LINK(DBChangeDialog_Impl, DoubleClickHdl, SvTabListBox*, /*pLB*/)
{
    EndDialog(RET_OK);
    return 0;
}
/* -----------------18.11.99 11:17-------------------

 --------------------------------------------------*/
/*IMPL_LINK(DBChangeDialog_Impl, EndDragHdl, HeaderBar*, pHB)
{
    long nTabs[3];
    nTabs[0] = 2;// Number of Tabs
    nTabs[1] = 0;
    nTabs[2] = pHB->GetItemSize( 1 );
    aSelectionLB.SetTabs( &nTabs[0], MAP_PIXEL );
    return 0;
};*/

/*-- 18.11.99 10:35:20---------------------------------------------------

  -----------------------------------------------------------------------*/
DBChangeDialog_Impl::~DBChangeDialog_Impl()
{
}
/* -----------------18.11.99 12:36-------------------

 --------------------------------------------------*/
String  DBChangeDialog_Impl::GetCurrentURL()const
{
    String sRet;
    SvLBoxEntry* pEntry = aSelectionLB.FirstSelected();
    if(pEntry)
    {
        sRet = aSelectionLB.GetEntryText(pEntry, 0);
    }
    return sRet;
}

// #100312# --------------------------------------------------------------------
// XDispatchProvider
BibInterceptorHelper::BibInterceptorHelper( ::bib::BibBeamer* pBibBeamer, ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatch > xDispatch)
{
    if( pBibBeamer )
    {
        xInterception = pBibBeamer->getDispatchProviderInterception();
        if( xInterception.is() )
            xInterception->registerDispatchProviderInterceptor( this );
    }
    if( xDispatch.is() )
        xFormDispatch = xDispatch;
}

BibInterceptorHelper::~BibInterceptorHelper( )
{
}

void BibInterceptorHelper::ReleaseInterceptor()
{
    if ( xInterception.is() )
        xInterception->releaseDispatchProviderInterceptor( this );
    xInterception.clear();
}

::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatch > SAL_CALL
    BibInterceptorHelper::queryDispatch( const ::com::sun::star::util::URL& aURL, const ::rtl::OUString& aTargetFrameName, sal_Int32 nSearchFlags ) throw (::com::sun::star::uno::RuntimeException)
{
    Reference< XDispatch > xReturn;

    String aCommand( aURL.Path );
    if ( aCommand.EqualsAscii("FormSlots/ConfirmDeletion") )
        xReturn = xFormDispatch;
    else
        if ( xSlaveDispatchProvider.is() )
            xReturn = xSlaveDispatchProvider->queryDispatch( aURL, aTargetFrameName, nSearchFlags);

    return xReturn;
}

::com::sun::star::uno::Sequence< ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatch > > SAL_CALL
    BibInterceptorHelper::queryDispatches( const ::com::sun::star::uno::Sequence< ::com::sun::star::frame::DispatchDescriptor >& aDescripts ) throw (::com::sun::star::uno::RuntimeException)
{
    Sequence< Reference< XDispatch> > aReturn( aDescripts.getLength() );
    Reference< XDispatch >* pReturn = aReturn.getArray();
    const DispatchDescriptor* pDescripts = aDescripts.getConstArray();
    for ( sal_Int16 i=0; i<aDescripts.getLength(); ++i, ++pReturn, ++pDescripts )
    {
        *pReturn = queryDispatch( pDescripts->FeatureURL, pDescripts->FrameName, pDescripts->SearchFlags );
    }
    return aReturn;
}

// XDispatchProviderInterceptor
::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatchProvider > SAL_CALL
    BibInterceptorHelper::getSlaveDispatchProvider(  ) throw (::com::sun::star::uno::RuntimeException)
{
    return xSlaveDispatchProvider;
}

void SAL_CALL BibInterceptorHelper::setSlaveDispatchProvider( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatchProvider >& xNewSlaveDispatchProvider ) throw (::com::sun::star::uno::RuntimeException)
{
    xSlaveDispatchProvider = xNewSlaveDispatchProvider;
}

::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatchProvider > SAL_CALL
    BibInterceptorHelper::getMasterDispatchProvider(  ) throw (::com::sun::star::uno::RuntimeException)
{
    return xMasterDispatchProvider;
}

void SAL_CALL BibInterceptorHelper::setMasterDispatchProvider( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatchProvider >& xNewMasterDispatchProvider ) throw (::com::sun::star::uno::RuntimeException)
{
    xMasterDispatchProvider = xNewMasterDispatchProvider;
}

//-----------------------------------------------------------------------------
#define STR_UID "uid"
::rtl::OUString gGridName(C2U("theGrid"));
::rtl::OUString gViewName(C2U("theView"));
::rtl::OUString gGlobalName(C2U("theGlobals"));
::rtl::OUString gBeamerSize(C2U("theBeamerSize"));
::rtl::OUString gViewSize(C2U("theViewSize"));

BibDataManager::BibDataManager()
    :BibDataManager_Base( GetMutex() )
    // #100312# --------------
    ,m_pInterceptorHelper( NULL )
    ,m_aLoadListeners(m_aMutex)
    ,pBibView( NULL )
    ,pToolbar(0)
{
}

/* --------------------------------------------------

 --------------------------------------------------*/
BibDataManager::~BibDataManager()
{
    Reference< XLoadable >      xLoad( m_xForm, UNO_QUERY );
    Reference< XPropertySet >   xPrSet( m_xForm, UNO_QUERY );
    Reference< XComponent >     xComp( m_xForm, UNO_QUERY );
    if ( m_xForm.is() )
    {
        Reference< XComponent >  xConnection;
        xPrSet->getPropertyValue(C2U("ActiveConnection")) >>= xConnection;
        RemoveMeAsUidListener();
        if (xLoad.is())
            xLoad->unload();
        if (xComp.is())
            xComp->dispose();
        if(xConnection.is())
            xConnection->dispose();
        m_xForm = NULL;
    }
    // #100312# ----------------
    if( m_pInterceptorHelper )
    {
        m_pInterceptorHelper->ReleaseInterceptor();
        m_pInterceptorHelper->release();
        m_pInterceptorHelper = NULL;
    }
}
//------------------------------------------------------------------------
void BibDataManager::InsertFields(const Reference< XFormComponent > & _rxGrid)
{
    if ( !_rxGrid.is() )
        return;

    try
    {
        Reference< XNameContainer > xColContainer( _rxGrid, UNO_QUERY );
        // remove the old fields
        if ( xColContainer->hasElements() )
        {
            Sequence< ::rtl::OUString > aNames = xColContainer->getElementNames();
            const ::rtl::OUString* pNames = aNames.getConstArray();
            const ::rtl::OUString* pNamesEnd = pNames + aNames.getLength();
            for ( ; pNames != pNamesEnd; ++pNames )
                xColContainer->removeByName( *pNames );
        }

        Reference< XNameAccess >  xFields = getColumns( m_xForm );
        if (!xFields.is())
            return;

        Reference< XGridColumnFactory > xColFactory( _rxGrid, UNO_QUERY );

        Reference< XPropertySet >  xField;

        Sequence< ::rtl::OUString > aFields( xFields->getElementNames() );
        const ::rtl::OUString* pFields = aFields.getConstArray();
        const ::rtl::OUString* pFieldsEnd = pFields + aFields.getLength();

        for ( ; pFields != pFieldsEnd; ++pFields )
        {
            xFields->getByName( *pFields ) >>= xField;

            ::rtl::OUString sCurrentModelType;
            const ::rtl::OUString sType(C2U("Type"));
            sal_Int32 nType = 0;
            sal_Bool bIsFormatted           = sal_False;
            sal_Bool bFormattedIsNumeric    = sal_True;
            xField->getPropertyValue(sType) >>= nType;
            switch(nType)
            {
                case DataType::BIT:
                case DataType::BOOLEAN:
                    sCurrentModelType = C2U("CheckBox");
                    break;

                case DataType::BINARY:
                case DataType::VARBINARY:
                case DataType::LONGVARBINARY:
                case DataType::BLOB:
                    sCurrentModelType = C2U("TextField");
                    break;

                case DataType::VARCHAR:
                case DataType::LONGVARCHAR:
                case DataType::CHAR:
                case DataType::CLOB:
                    bFormattedIsNumeric = sal_False;
                    // _NO_ break !
                default:
                    sCurrentModelType = C2U("FormattedField");
                    bIsFormatted = sal_True;
                    break;
            }

            Reference< XPropertySet >  xCurrentCol = xColFactory->createColumn(sCurrentModelType);
            if (bIsFormatted)
            {
                ::rtl::OUString sFormatKey(C2U("FormatKey"));
                xCurrentCol->setPropertyValue(sFormatKey, xField->getPropertyValue(sFormatKey));
                Any aFormatted(&bFormattedIsNumeric, ::getBooleanCppuType());
                xCurrentCol->setPropertyValue(C2U("TreatAsNumber"), aFormatted);
            }
            Any aColName = makeAny( *pFields );
            xCurrentCol->setPropertyValue(FM_PROP_CONTROLSOURCE,    aColName);
            xCurrentCol->setPropertyValue(FM_PROP_LABEL, aColName);

            xColContainer->insertByName( *pFields, makeAny( xCurrentCol ) );
        }
    }
    catch(Exception& e )
    {
        (void) e;   // make compiler happy
        DBG_ERROR("Exception in BibDataManager::InsertFields");
    }
}
/* --------------------------------------------------

 --------------------------------------------------*/
Reference< awt::XControlModel > BibDataManager::updateGridModel()
{
    return updateGridModel( m_xForm );
}
/* --------------------------------------------------

 --------------------------------------------------*/
Reference< awt::XControlModel > BibDataManager::updateGridModel(const Reference< XForm > & xDbForm)
{
    try
    {
        Reference< XPropertySet >  aFormPropSet( xDbForm, UNO_QUERY );
        ::rtl::OUString sName;
        aFormPropSet->getPropertyValue(C2U("Command")) >>= sName;

        if ( !m_xGridModel.is() )
        {
            m_xGridModel = createGridModel( gGridName );

            Reference< XNameContainer >  xNameCont(xDbForm, UNO_QUERY);
//          if (xNameCont->hasByName(sName))
//              xNameCont->removeByName(sName);
//
            xNameCont->insertByName( sName, makeAny( m_xGridModel ) );
        }

        // insert the fields
        Reference< XFormComponent > xFormComp( m_xGridModel, UNO_QUERY );
        InsertFields( xFormComp );
    }
    catch(Exception& e )
    {
        (void) e;   // make compiler happy
        DBG_ERROR("::updateGridModel: something went wrong !");
    }


    return m_xGridModel;
}
/* --------------------------------------------------

 --------------------------------------------------*/
Reference< XForm >  BibDataManager::createDatabaseForm(BibDBDescriptor& rDesc)
{
    Reference< XForm >  xResult;
    try
    {
        Reference< XMultiServiceFactory >  xMgr = comphelper::getProcessServiceFactory();
        m_xForm = Reference< XForm > ( xMgr->createInstance( C2U("com.sun.star.form.component.Form") ), UNO_QUERY );

        Reference< XPropertySet >  aPropertySet( m_xForm, UNO_QUERY );

        aDataSourceURL = rDesc.sDataSource;
        if(aPropertySet.is())
        {
            Any aVal;
            aVal <<= (sal_Int32)ResultSetType::SCROLL_INSENSITIVE;
            aPropertySet->setPropertyValue(C2U("ResultSetType"),aVal );
            aVal <<= (sal_Int32)ResultSetConcurrency::READ_ONLY;
            aPropertySet->setPropertyValue(C2U("ResultSetConcurrency"), aVal);

            //Caching for Performance
            aVal <<= (sal_Int32)50;
            aPropertySet->setPropertyValue(C2U("FetchSize"), aVal);

            Reference< XConnection >    xConnection = getConnection(rDesc.sDataSource);
            aVal <<= xConnection;
            aPropertySet->setPropertyValue(C2U("ActiveConnection"), aVal);

            Reference< XTablesSupplier >  xSupplyTables(xConnection, UNO_QUERY);
            Reference< XNameAccess >  xTables = xSupplyTables.is() ?
                                xSupplyTables->getTables() : Reference< XNameAccess > ();

            Sequence< ::rtl::OUString > aTableNameSeq;
            if (xTables.is())
                aTableNameSeq = xTables->getElementNames();

            if(aTableNameSeq.getLength() > 0)
            {
                const ::rtl::OUString* pTableNames = aTableNameSeq.getConstArray();
                if(rDesc.sTableOrQuery.getLength())
                    aActiveDataTable = rDesc.sTableOrQuery;
                else
                {
                    rDesc.sTableOrQuery = aActiveDataTable = pTableNames[0];
                    rDesc.nCommandType = CommandType::TABLE;
                }

                aVal <<= aActiveDataTable;
                aPropertySet->setPropertyValue(C2U("Command"), aVal);
                aVal <<= rDesc.nCommandType;
                aPropertySet->setPropertyValue(C2U("CommandType"), aVal);


                Reference< XDatabaseMetaData >  xMetaData = xConnection->getMetaData();
                aQuoteChar = xMetaData->getIdentifierQuoteString();

                Reference< XMultiServiceFactory > xFactory(xConnection, UNO_QUERY);
                if ( xFactory.is() )
                    m_xParser.set( xFactory->createInstance( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.sdb.SingleSelectQueryComposer" ) ) ), UNO_QUERY );

                ::rtl::OUString aString(C2U("SELECT * FROM "));

                ::rtl::OUString sCatalog, sSchema, sName;
                ::dbtools::qualifiedNameComponents( xMetaData, aActiveDataTable, sCatalog, sSchema, sName, ::dbtools::eInDataManipulation );
                aString += ::dbtools::composeTableNameForSelect( xConnection, sCatalog, sSchema, sName );

                m_xParser->setElementaryQuery(aString);
                BibConfig* pConfig = BibModul::GetConfig();
                pConfig->setQueryField(getQueryField());
                startQueryWith(pConfig->getQueryText());

                xResult = m_xForm;
            }
        }
    }
    catch(Exception& e )
    {
        (void) e;   // make compiler happy
        DBG_ERROR("::createDatabaseForm: something went wrong !");
    }


    return xResult;
}
//------------------------------------------------------------------------
Sequence< ::rtl::OUString > BibDataManager::getDataSources()
{
    Sequence< ::rtl::OUString > aTableNameSeq;

    try
    {
        Reference< XTablesSupplier >  xSupplyTables( getConnection( m_xForm ), UNO_QUERY );
        Reference< XNameAccess >  xTables;
        if (xSupplyTables.is())
            xTables = xSupplyTables->getTables();
        if (xTables.is())
            aTableNameSeq = xTables->getElementNames();
    }
    catch(Exception& e )
    {
        (void) e;   // make compiler happy
        DBG_ERROR("::getDataSources: something went wrong !");
    }


    return aTableNameSeq;
}
//------------------------------------------------------------------------
::rtl::OUString BibDataManager::getActiveDataTable()
{
    return aActiveDataTable;
}
//------------------------------------------------------------------------
void BibDataManager::setFilter(const ::rtl::OUString& rQuery)
{
    if(!m_xParser.is())
        return;
    try
    {
        m_xParser->setFilter( rQuery );
        ::rtl::OUString aQuery = m_xParser->getFilter();
        Reference< XPropertySet >  xFormProps( m_xForm, UNO_QUERY_THROW );
        xFormProps->setPropertyValue( C2U( "Filter" ), makeAny( aQuery ) );
        xFormProps->setPropertyValue( C2U( "ApplyFilter" ), makeAny( sal_True ) );
        reload();
    }
    catch(Exception& e )
    {
        DBG_UNHANDLED_EXCEPTION();
    }


}
//------------------------------------------------------------------------
::rtl::OUString BibDataManager::getFilter()
{

    ::rtl::OUString aQueryString;
    try
    {
        Reference< XPropertySet > xFormProps( m_xForm, UNO_QUERY_THROW );
        OSL_VERIFY( xFormProps->getPropertyValue( C2U( "Filter" ) ) >>= aQueryString );
    }
    catch( const Exception& )
    {
        DBG_UNHANDLED_EXCEPTION();
    }


    return aQueryString;

}
//------------------------------------------------------------------------
Sequence< ::rtl::OUString > BibDataManager::getQueryFields()
{
    Sequence< ::rtl::OUString > aFieldSeq;
    Reference< XNameAccess >  xFields = getColumns( m_xForm );
    if (xFields.is())
        aFieldSeq = xFields->getElementNames();
    return aFieldSeq;
}
//------------------------------------------------------------------------
::rtl::OUString BibDataManager::getQueryField()
{
    BibConfig* pConfig = BibModul::GetConfig();
    ::rtl::OUString aFieldString = pConfig->getQueryField();
    if(!aFieldString.getLength())
    {
        Sequence< ::rtl::OUString > aSeq = getQueryFields();
        const ::rtl::OUString* pFields = aSeq.getConstArray();
        if(aSeq.getLength()>0)
        {
            aFieldString=pFields[0];
        }
    }
    return aFieldString;
}
//------------------------------------------------------------------------
void BibDataManager::startQueryWith(const ::rtl::OUString& rQuery)
{
    BibConfig* pConfig = BibModul::GetConfig();
    pConfig->setQueryText( rQuery );

    ::rtl::OUString aQueryString;
    if(rQuery.getLength()>0)
    {
        aQueryString=aQuoteChar;
        aQueryString+=getQueryField();
        aQueryString+=aQuoteChar;
        aQueryString+=C2U(" like '");
        String sQuery(rQuery);
        sQuery.SearchAndReplaceAll('?','_');
        sQuery.SearchAndReplaceAll('*','%');
        aQueryString += sQuery;
        aQueryString+=C2U("%'");
    }
    setFilter(aQueryString);
}
/* -----------------03.12.99 15:05-------------------

 --------------------------------------------------*/
void BibDataManager::setActiveDataSource(const ::rtl::OUString& rURL)
{
    ::rtl::OUString uTable;
    ::rtl::OUString sTmp(aDataSourceURL);
    aDataSourceURL = rURL;

    Reference< XPropertySet >  aPropertySet( m_xForm, UNO_QUERY );
    if(aPropertySet.is())
    {
        unload();

        Reference< XComponent >  xOldConnection;
        aPropertySet->getPropertyValue(C2U("ActiveConnection")) >>= xOldConnection;

        Reference< XConnection >    xConnection = getConnection(rURL);
        if(!xConnection.is())
        {
            aDataSourceURL = sTmp;
            return;
        }
        Any aVal; aVal <<= xConnection;
        aPropertySet->setPropertyValue(C2U("ActiveConnection"), aVal);
        Reference< XMultiServiceFactory >   xFactory(xConnection, UNO_QUERY);
        if ( xFactory.is() )
            m_xParser.set( xFactory->createInstance( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.sdb.SingleSelectQueryComposer" ) ) ), UNO_QUERY );

        if(xOldConnection.is())
            xOldConnection->dispose();

        Sequence< ::rtl::OUString > aTableNameSeq;
        Reference< XTablesSupplier >  xSupplyTables(xConnection, UNO_QUERY);
        if(xSupplyTables.is())
        {
            Reference< XNameAccess >  xAccess = xSupplyTables->getTables();
            aTableNameSeq = xAccess->getElementNames();
        }
        if(aTableNameSeq.getLength() > 0)
        {
            const ::rtl::OUString* pTableNames = aTableNameSeq.getConstArray();
            aActiveDataTable = pTableNames[0];
            aVal <<= aActiveDataTable;
            aPropertySet->setPropertyValue(C2U("Command"), aVal);
            aPropertySet->setPropertyValue(C2U("CommandType"), makeAny(CommandType::TABLE));
            //Caching for Performance
            aVal <<= (sal_Int32)50;
            aPropertySet->setPropertyValue(C2U("FetchSize"), aVal);
            ::rtl::OUString aString(C2U("SELECT * FROM "));
            // quote the table name which may contain catalog.schema.table
            Reference<XDatabaseMetaData> xMetaData(xConnection->getMetaData(),UNO_QUERY);
            aQuoteChar = xMetaData->getIdentifierQuoteString();

            ::rtl::OUString sCatalog, sSchema, sName;
            ::dbtools::qualifiedNameComponents( xMetaData, aActiveDataTable, sCatalog, sSchema, sName, ::dbtools::eInDataManipulation );
            aString += ::dbtools::composeTableNameForSelect( xConnection, sCatalog, sSchema, sName );

            m_xParser->setElementaryQuery(aString);
            BibConfig* pConfig = BibModul::GetConfig();
            pConfig->setQueryField(getQueryField());
            startQueryWith(pConfig->getQueryText());
            setActiveDataTable(aActiveDataTable);
        }
        FeatureStateEvent aEvent;
        util::URL aURL;
        aEvent.IsEnabled  = sal_True;
        aEvent.Requery    = sal_False;
        aEvent.FeatureDescriptor = getActiveDataTable();

        aEvent.State = makeAny( getDataSources() );

        if(pToolbar)
        {
            aURL.Complete =C2U(".uno:Bib/source");
            aEvent.FeatureURL = aURL;
            pToolbar->statusChanged( aEvent );
        }

        updateGridModel();
        load();
    }
}

/* --------------------------------------------------

 --------------------------------------------------*/
void BibDataManager::setActiveDataTable(const ::rtl::OUString& rTable)
{
    ResetIdentifierMapping();
    try
    {
        Reference< XPropertySet >  aPropertySet( m_xForm, UNO_QUERY );

        if(aPropertySet.is())
        {
            Reference< XConnection >    xConnection = getConnection( m_xForm );
            Reference< XTablesSupplier >  xSupplyTables(xConnection, UNO_QUERY);
            Reference< XNameAccess > xAccess = xSupplyTables->getTables();
            Sequence< ::rtl::OUString > aTableNameSeq = xAccess->getElementNames();
            sal_uInt32 nCount = aTableNameSeq.getLength();

            const ::rtl::OUString* pTableNames = aTableNameSeq.getConstArray();
            const ::rtl::OUString* pTableNamesEnd = pTableNames + nCount;

            for ( ; pTableNames != pTableNamesEnd; ++pTableNames )
            {
                if ( rTable == *pTableNames )
                {
                    aActiveDataTable = rTable;
                    Any aVal; aVal <<= rTable;
                    aPropertySet->setPropertyValue( C2U("Command"), aVal );
                    break;
                }
            }
            if (pTableNames != pTableNamesEnd)
            {
                Reference< XDatabaseMetaData >  xMetaData = xConnection->getMetaData();
                aQuoteChar = xMetaData->getIdentifierQuoteString();

                Reference< XMultiServiceFactory > xFactory(xConnection, UNO_QUERY);
                if ( xFactory.is() )
                    m_xParser.set( xFactory->createInstance( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.sdb.SingleSelectQueryComposer" ) ) ), UNO_QUERY );

                ::rtl::OUString aString(C2U("SELECT * FROM "));

                ::rtl::OUString sCatalog, sSchema, sName;
                ::dbtools::qualifiedNameComponents( xMetaData, aActiveDataTable, sCatalog, sSchema, sName, ::dbtools::eInDataManipulation );
                aString += ::dbtools::composeTableNameForSelect( xConnection, sCatalog, sSchema, sName );

                m_xParser->setElementaryQuery(aString);

                BibConfig* pConfig = BibModul::GetConfig();
                pConfig->setQueryField(getQueryField());
                startQueryWith(pConfig->getQueryText());

                BibDBDescriptor aDesc;
                aDesc.sDataSource = aDataSourceURL;
                aDesc.sTableOrQuery = aActiveDataTable;
                aDesc.nCommandType = CommandType::TABLE;
                BibModul::GetConfig()->SetBibliographyURL(aDesc);
            }
        }
    }
    catch(Exception& e )
    {
        (void) e;   // make compiler happy
        DBG_ERROR("::setActiveDataTable: something went wrong !");
    }

}

//------------------------------------------------------------------------
void SAL_CALL BibDataManager::load(  ) throw (RuntimeException)
{
    if ( isLoaded() )
        // nothing to do
        return;

    Reference< XLoadable > xFormAsLoadable( m_xForm, UNO_QUERY );
    DBG_ASSERT( xFormAsLoadable.is() || !m_xForm.is(), "BibDataManager::load: invalid form!");
    if ( xFormAsLoadable.is() )
    {
        xFormAsLoadable->load();
        SetMeAsUidListener();

        EventObject aEvt( static_cast< XWeak* >( this ) );
        m_aLoadListeners.notifyEach( &XLoadListener::loaded, aEvt );
    }
}

//------------------------------------------------------------------------
void SAL_CALL BibDataManager::unload(  ) throw (RuntimeException)
{
    if ( !isLoaded() )
        // nothing to do
        return;

    Reference< XLoadable >xFormAsLoadable( m_xForm, UNO_QUERY );
    DBG_ASSERT( xFormAsLoadable.is() || !m_xForm.is(), "BibDataManager::unload: invalid form!");
    if ( xFormAsLoadable.is() )
    {
        EventObject aEvt( static_cast< XWeak* >( this ) );

        {
            m_aLoadListeners.notifyEach( &XLoadListener::unloading, aEvt );
        }

        RemoveMeAsUidListener();
        xFormAsLoadable->unload();

        {
            m_aLoadListeners.notifyEach( &XLoadListener::unloaded, aEvt );
        }
    }
}

//------------------------------------------------------------------------
void SAL_CALL BibDataManager::reload(  ) throw (RuntimeException)
{
    if ( !isLoaded() )
        // nothing to do
        return;

    Reference< XLoadable >xFormAsLoadable( m_xForm, UNO_QUERY );
    DBG_ASSERT( xFormAsLoadable.is() || !m_xForm.is(), "BibDataManager::unload: invalid form!");
    if ( xFormAsLoadable.is() )
    {
        EventObject aEvt( static_cast< XWeak* >( this ) );

        {
            m_aLoadListeners.notifyEach( &XLoadListener::reloading, aEvt );
        }

        xFormAsLoadable->reload();

        {
            m_aLoadListeners.notifyEach( &XLoadListener::reloaded, aEvt );
        }
    }
}

//------------------------------------------------------------------------
sal_Bool SAL_CALL BibDataManager::isLoaded(  ) throw (RuntimeException)
{
    Reference< XLoadable >xFormAsLoadable( m_xForm, UNO_QUERY );
    DBG_ASSERT( xFormAsLoadable.is() || !m_xForm.is(), "BibDataManager::isLoaded: invalid form!");

    sal_Bool bLoaded = sal_False;
    if ( xFormAsLoadable.is() )
        bLoaded = xFormAsLoadable->isLoaded();
    return bLoaded;
}

//------------------------------------------------------------------------
void SAL_CALL BibDataManager::addLoadListener( const Reference< XLoadListener >& aListener ) throw (RuntimeException)
{
    m_aLoadListeners.addInterface( aListener );
}

//------------------------------------------------------------------------
void SAL_CALL BibDataManager::removeLoadListener( const Reference< XLoadListener >& aListener ) throw (RuntimeException)
{
    m_aLoadListeners.removeInterface( aListener );
}

//------------------------------------------------------------------------
Reference< awt::XControlModel > BibDataManager::createGridModel(const ::rtl::OUString& rName)
{
    Reference< awt::XControlModel > xModel;

    try
    {
        // create the control model
        Reference< XMultiServiceFactory >  xMgr = ::comphelper::getProcessServiceFactory();
        Reference< XInterface >  xObject = xMgr->createInstance(C2U("com.sun.star.form.component.GridControl"));
        xModel=Reference< awt::XControlModel > ( xObject, UNO_QUERY );

        // set the
        Reference< XPropertySet > xPropSet( xModel, UNO_QUERY );
        xPropSet->setPropertyValue( C2U("Name"), makeAny( rName ) );

        // set the name of the to-be-created control
        ::rtl::OUString aControlName(C2U("com.sun.star.form.control.InteractionGridControl"));
        Any aAny; aAny <<= aControlName;
        xPropSet->setPropertyValue( C2U("DefaultControl"),aAny );

        // the the helpURL
        ::rtl::OUString uProp(C2U("HelpURL"));
        Reference< XPropertySetInfo > xPropInfo = xPropSet->getPropertySetInfo();
        if (xPropInfo->hasPropertyByName(uProp))
        {
            ::rtl::OUString sId = ::rtl::OUString::createFromAscii( INET_HID_SCHEME );
            sId += ::rtl::OUString::createFromAscii( HID_BIB_DB_GRIDCTRL );
            xPropSet->setPropertyValue( uProp, makeAny( sId ) );
        }
    }
    catch(Exception& e )
    {
        (void) e;   // make compiler happy
        DBG_ERROR("::createGridModel: something went wrong !");
    }


    return xModel;
}
//------------------------------------------------------------------------
::rtl::OUString BibDataManager::getControlName(sal_Int32 nFormatKey )
{
    ::rtl::OUString aResStr;
    switch (nFormatKey)
    {
        case DataType::BIT:
        case DataType::BOOLEAN:
            aResStr=C2U("CheckBox");
            break;
        case DataType::TINYINT:
        case DataType::SMALLINT:
        case DataType::INTEGER:
            aResStr=C2U("NumericField");   ;
            break;
        case DataType::REAL:
        case DataType::DOUBLE:
        case DataType::NUMERIC:
        case DataType::DECIMAL:
            aResStr=C2U("FormattedField");
            break;
        case DataType::TIMESTAMP:
            aResStr=C2U("FormattedField");
            break;
        case DataType::DATE:
            aResStr=C2U("DateField");
            break;
        case DataType::TIME:
            aResStr=C2U("TimeField");
            break;
        case DataType::CHAR:
        case DataType::VARCHAR:
        case DataType::LONGVARCHAR:
        default:
            aResStr=C2U("TextField");
            break;
    }
    return aResStr;
}
//------------------------------------------------------------------------
Reference< awt::XControlModel > BibDataManager::loadControlModel(
                    const ::rtl::OUString& rName, sal_Bool bForceListBox)
{
    Reference< awt::XControlModel > xModel;
    ::rtl::OUString aName(C2U("View_"));
    aName += rName;

    try
    {
        Reference< XNameAccess >  xFields = getColumns( m_xForm );
        if (!xFields.is())
            return xModel;
        Reference< XPropertySet >  xField;

        Any aElement;

        if(xFields->hasByName(rName))
        {
            aElement = xFields->getByName(rName);
            aElement >>= xField;
            Reference< XPropertySetInfo >  xInfo = xField.is() ? xField->getPropertySetInfo() : Reference< XPropertySetInfo > ();

            ::rtl::OUString sCurrentModelType;
            const ::rtl::OUString sType(C2U("Type"));
            sal_Int32 nFormatKey = 0;
            xField->getPropertyValue(sType) >>= nFormatKey;

            ::rtl::OUString aInstanceName(C2U("com.sun.star.form.component."));

            if (bForceListBox)
                aInstanceName += C2U("ListBox");
            else
                aInstanceName += getControlName(nFormatKey);

            Reference< XMultiServiceFactory >  xMgr = comphelper::getProcessServiceFactory();
            Reference< XInterface >  xObject = xMgr->createInstance(aInstanceName);
            xModel=Reference< awt::XControlModel > ( xObject, UNO_QUERY );
            Reference< XPropertySet >  xPropSet( xModel, UNO_QUERY );
            Any aFieldName; aFieldName <<= aName;

            xPropSet->setPropertyValue( FM_PROP_NAME,aFieldName);
            xPropSet->setPropertyValue( FM_PROP_CONTROLSOURCE, makeAny( rName ) );
            xPropSet->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "NativeWidgetLook" ) ), makeAny( (sal_Bool)sal_True ) );

            Reference< XFormComponent >  aFormComp(xModel,UNO_QUERY );

            Reference< XNameContainer >  xNameCont( m_xForm, UNO_QUERY );
            xNameCont->insertByName(aName, makeAny( aFormComp ) );

            // now if the form where we inserted the new model is already loaded, notify the model of this
            // Note that this implementation below is a HACK as it relies on the fact that the model adds itself
            // as load listener to it's parent, which is an implementation detail of the model.
            //
            // the better solution would be the following:
            // in the current scenario, we insert a control model into a form. This results in the control model
            // adding itself as load listener to the form. Now, the form should realize that it's already loaded
            // and notify the model (which it knows as XLoadListener only) immediately. This seems to make sense.
            // (as an anologon to the XStatusListener semantics).
            //
            // But this would be way too risky for this last-day fix here.
            // 97140 - 30.01.2002 - fs@openoffice.org
            Reference< XLoadable > xLoad( m_xForm, UNO_QUERY );
            if ( xLoad.is() && xLoad->isLoaded() )
            {
                Reference< XLoadListener > xListener( aFormComp, UNO_QUERY );
                if ( xListener.is() )
                {
                    EventObject aLoadSource;
                    aLoadSource.Source = xLoad;
                    xListener->loaded( aLoadSource );
                }
            }
        }
    }
    catch(Exception& e )
    {
        (void) e;   // make compiler happy
        DBG_ERROR("::loadControlModel: something went wrong !");
    }
    return xModel;
}
//------------------------------------------------------------------------
void SAL_CALL BibDataManager::disposing()
{
    BibDataManager_Base::WeakComponentImplHelperBase::disposing();
}

//------------------------------------------------------------------------
void BibDataManager::disposing( const EventObject& /*Source*/ ) throw( ::com::sun::star::uno::RuntimeException )
{
    // not interested in
}

//------------------------------------------------------------------------
void BibDataManager::propertyChange(const beans::PropertyChangeEvent& evt) throw( RuntimeException )
{
    try
    {
        sal_Bool bFlag=sal_False;
        if(evt.PropertyName == FM_PROP_VALUE)
        {
            if( evt.NewValue.getValueType() == ::getCppuType((Reference<io::XInputStream>*)0) )
            {
                Reference< io::XDataInputStream >  xStream(
                    *(const Reference< io::XInputStream > *)evt.NewValue.getValue(), UNO_QUERY );
                aUID <<= xStream->readUTF();
            }
            else
                aUID = evt.NewValue;

            Reference< XRowLocate > xLocate(xBibCursor, UNO_QUERY);
            DBG_ASSERT(xLocate.is(), "BibDataManager::propertyChange : invalid cursor !");
            bFlag = xLocate->moveToBookmark(aUID);
        }
    }
    catch(Exception& e )
    {
        (void) e;   // make compiler happy
        DBG_ERROR("::propertyChange: something went wrong !");
    }


}
//------------------------------------------------------------------------
void BibDataManager::SetMeAsUidListener()
{
try
{
    Reference< XNameAccess >  xFields = getColumns( m_xForm );
    if (!xFields.is())
        return;

    Sequence< ::rtl::OUString > aFields(xFields->getElementNames());
    const ::rtl::OUString* pFields = aFields.getConstArray();
    sal_Int32 nCount=aFields.getLength();
    String StrUID(C2S(STR_UID));
    ::rtl::OUString theFieldName;
    for( sal_Int32 i=0; i<nCount; i++ )
    {
        String aName= pFields[i];

        if(aName.EqualsIgnoreCaseAscii(StrUID))
        {
            theFieldName=pFields[i];
            break;
        }
    }

    if(theFieldName.getLength()>0)
    {
        Reference< XPropertySet >  xPropSet;
        Any aElement;

        aElement = xFields->getByName(theFieldName);
        xPropSet = *(Reference< XPropertySet > *)aElement.getValue();

        xPropSet->addPropertyChangeListener(FM_PROP_VALUE, this);
    }

}
catch(Exception& e )
{
    (void) e;   // make compiler happy
    DBG_ERROR("Exception in BibDataManager::SetMeAsUidListener");
}


}
//------------------------------------------------------------------------
void BibDataManager::RemoveMeAsUidListener()
{
try
{
    Reference< XNameAccess >  xFields = getColumns( m_xForm );
    if (!xFields.is())
        return;


    Sequence< ::rtl::OUString > aFields(xFields->getElementNames());
    const ::rtl::OUString* pFields = aFields.getConstArray();
    sal_Int32 nCount=aFields.getLength();
    String StrUID(C2S(STR_UID));
    ::rtl::OUString theFieldName;
    for( sal_Int32 i=0; i<nCount; i++ )
    {
        String aName= pFields[i];

        if(aName.EqualsIgnoreCaseAscii(StrUID))
        {
            theFieldName=pFields[i];
            break;
        }
    }

    if(theFieldName.getLength()>0)
    {
        Reference< XPropertySet >  xPropSet;
        Any aElement;

        aElement = xFields->getByName(theFieldName);
        xPropSet = *(Reference< XPropertySet > *)aElement.getValue();

        xPropSet->removePropertyChangeListener(FM_PROP_VALUE, this);
    }

}
catch(Exception& e )
{
    (void) e;   // make compiler happy
    DBG_ERROR("Exception in BibDataManager::RemoveMeAsUidListener");
}


}
/* -----------------11.11.99 15:51-------------------

 --------------------------------------------------*/
void BibDataManager::CreateMappingDialog(Window* pParent)
{
    MappingDialog_Impl* pDlg = new MappingDialog_Impl(pParent, this);
    if(RET_OK == pDlg->Execute() && pBibView)
    {
        reload();
//      unload();
//      pBibView->UpdatePages();
//      load();
    }
    delete pDlg;
}
/* --------------------------------------------------

 --------------------------------------------------*/
::rtl::OUString BibDataManager::CreateDBChangeDialog(Window* pParent)
{
    ::rtl::OUString uRet;
    DBChangeDialog_Impl * pDlg = new DBChangeDialog_Impl(pParent, this );
    if(RET_OK == pDlg->Execute())
    {
        String sNewURL = pDlg->GetCurrentURL();
        if(sNewURL != String(getActiveDataSource()))
        {
            uRet = sNewURL;
        }
    }
    delete pDlg;
    return uRet;
}
/*-- 18.05.2004 15:20:15---------------------------------------------------

  -----------------------------------------------------------------------*/
void BibDataManager::DispatchDBChangeDialog()
{
    if(pToolbar)
        pToolbar->SendDispatch(TBC_BT_CHANGESOURCE, Sequence< PropertyValue >());
}
/* -----------------06.12.99 15:11-------------------

 --------------------------------------------------*/
const ::rtl::OUString& BibDataManager::GetIdentifierMapping()
{
    if(!sIdentifierMapping.getLength())
    {
        BibConfig* pConfig = BibModul::GetConfig();
        BibDBDescriptor aDesc;
        aDesc.sDataSource = getActiveDataSource();
        aDesc.sTableOrQuery = getActiveDataTable();
        aDesc.nCommandType = CommandType::TABLE;
        const Mapping* pMapping = pConfig->GetMapping(aDesc);
        sIdentifierMapping = pConfig->GetDefColumnName(IDENTIFIER_POS);
        if(pMapping)
        {
            for(sal_uInt16 nEntry = 0; nEntry < COLUMN_COUNT; nEntry++)
            {
                if(pMapping->aColumnPairs[nEntry].sLogicalColumnName == sIdentifierMapping)
                {
                    sIdentifierMapping = pMapping->aColumnPairs[nEntry].sRealColumnName;
                    break;
                }
            }
        }
    }
    return sIdentifierMapping;
}
/* -----------------------------20.11.00 10:31--------------------------------

 ---------------------------------------------------------------------------*/
void BibDataManager::SetToolbar(BibToolBar* pSet)
{
    pToolbar = pSet;
    if(pToolbar)
        pToolbar->SetDatMan(*this);
}
/* -----------------------------08.05.2002 09:26------------------------------

 ---------------------------------------------------------------------------*/
uno::Reference< form::runtime::XFormController > BibDataManager::GetFormController()
{
    if(!m_xFormCtrl.is())
    {
        Reference< lang::XMultiServiceFactory > xMgr = comphelper::getProcessServiceFactory();
        m_xFormCtrl = uno::Reference< form::runtime::XFormController > (
            xMgr->createInstance(C2U("com.sun.star.form.runtime.FormController")), UNO_QUERY);
        m_xFormCtrl->setModel(uno::Reference< awt::XTabControllerModel > (getForm(), UNO_QUERY));
        // #100312# -------------
        m_xFormDispatch = uno::Reference< frame::XDispatch > ( m_xFormCtrl, UNO_QUERY);
    }
    return m_xFormCtrl;
}

// #100312# ----------
void BibDataManager::RegisterInterceptor( ::bib::BibBeamer* pBibBeamer)
{
    DBG_ASSERT( !m_pInterceptorHelper, "BibDataManager::RegisterInterceptor: called twice!" );

    if( pBibBeamer )
        m_pInterceptorHelper = new BibInterceptorHelper( pBibBeamer, m_xFormDispatch);
    if( m_pInterceptorHelper )
        m_pInterceptorHelper->acquire();
}

/*-- 18.05.2004 17:04:20---------------------------------------------------

  -----------------------------------------------------------------------*/
sal_Bool BibDataManager::HasActiveConnection()const
{
    sal_Bool bRet = sal_False;
    Reference< XPropertySet >   xPrSet( m_xForm, UNO_QUERY );
    if( xPrSet.is() )
    {
        Reference< XComponent >  xConnection;
        xPrSet->getPropertyValue(C2U("ActiveConnection")) >>= xConnection;
        bRet = xConnection.is();
    }
    return bRet;
}
/*-- 04.06.2004 14:37:29---------------------------------------------------

  -----------------------------------------------------------------------*/
sal_Bool BibDataManager::HasActiveConnection()
{
    return getConnection( m_xForm ).is();
}