/**************************************************************
 * 
 * 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 <comphelper/processfactory.hxx>
#include <com/sun/star/awt/PosSize.hpp>
#include <com/sun/star/sdbc/XRowSet.hpp>
#include <com/sun/star/sdb/XColumn.hpp>
#include <com/sun/star/sdb/CommandType.hpp>
#include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
#include <com/sun/star/form/ListSourceType.hpp>
#include <com/sun/star/awt/XWindow.hpp>
#include <toolkit/helper/vclunohelper.hxx>
#include <cppuhelper/implbase1.hxx> // helper for implementations
#include "general.hxx"
#include "sections.hrc"
#include "bibresid.hxx"
#include "datman.hxx"
#include "bibconfig.hxx"
#include "bibprop.hrc"
#include "bib.hrc"
#include "bibmod.hxx"
#include "bibtools.hxx"
#include "bibliography.hrc"
#include <tools/debug.hxx>
#include <vcl/mnemonic.hxx>
#include <vcl/svapp.hxx>
#include <vcl/i18nhelp.hxx>
#include <vcl/mnemonic.hxx>
#include <algorithm>
#include <functional>
#include <vector>
#include <tools/urlobj.hxx>

using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::form;
using namespace ::com::sun::star::sdb;
using namespace ::rtl;

#define C2U(cChar) OUString::createFromAscii(cChar)
#define C2S(cChar) String::CreateFromAscii(cChar)
#define DISTANCE_CONTROL_TO_FIXEDTEXT 5

::Point lcl_MovePoint(const FixedText& rFixedText)
{
	::Point aRet(rFixedText.GetPosPixel());
	aRet.X() += rFixedText.GetSizePixel().Width();
    aRet.X() += DISTANCE_CONTROL_TO_FIXEDTEXT;
	return aRet;
}

//-----------------------------------------------------------------------------
OUString lcl_GetColumnName( const Mapping* pMapping, sal_uInt16 nIndexPos )
{
	BibConfig* pBibConfig = BibModul::GetConfig();
	OUString sRet = pBibConfig->GetDefColumnName(nIndexPos);
	if(pMapping)
		for(sal_uInt16 i = 0; i < COLUMN_COUNT; i++)
		{
			if(pMapping->aColumnPairs[i].sLogicalColumnName == sRet)
			{
				sRet = pMapping->aColumnPairs[i].sRealColumnName;
				break;
			}
		}
	return sRet;
}
/* -----------------------------04.01.00 10:54--------------------------------

 ---------------------------------------------------------------------------*/
class BibPosListener	:public cppu::WeakImplHelper1 <sdbc::XRowSetListener>
{
	BibGeneralPage* 	pParentPage;
public:
	BibPosListener(BibGeneralPage* pParent);

	//XPositioningListener
	virtual void SAL_CALL cursorMoved(const lang::EventObject& event) throw( uno::RuntimeException );
	virtual void SAL_CALL rowChanged(const lang::EventObject& /*event*/) throw( uno::RuntimeException ){ /* not interested in */ }
	virtual void SAL_CALL rowSetChanged(const lang::EventObject& /*event*/) throw( uno::RuntimeException ){ /* not interested in */ }

	//XEventListener
	virtual void SAL_CALL disposing(const lang::EventObject& Source) throw( uno::RuntimeException );

};
/* -----------------------------04.01.00 10:57--------------------------------

 ---------------------------------------------------------------------------*/
BibPosListener::BibPosListener(BibGeneralPage* pParent) :
	pParentPage(pParent)
{
}
/* -----------------------------04.01.00 10:57--------------------------------

 ---------------------------------------------------------------------------*/
void BibPosListener::cursorMoved(const lang::EventObject& /*aEvent*/) throw( uno::RuntimeException )
{
	try
	{
		uno::Reference< form::XBoundComponent >  xLstBox = pParentPage->GetTypeListBoxModel();
		uno::Reference< beans::XPropertySet >  xPropSet(xLstBox, UNO_QUERY);
		if(xPropSet.is())
		{
			BibConfig* pBibConfig = BibModul::GetConfig();
			BibDataManager* pDatMan = pParentPage->GetDataManager();
			BibDBDescriptor aDesc;
			aDesc.sDataSource = pDatMan->getActiveDataSource();
			aDesc.sTableOrQuery = pDatMan->getActiveDataTable();
			aDesc.nCommandType = CommandType::TABLE;

			const Mapping* pMapping = pBibConfig->GetMapping(aDesc);
			OUString sTypeMapping = pBibConfig->GetDefColumnName(AUTHORITYTYPE_POS);
			if(pMapping)
			{
				for(sal_uInt16 nEntry = 0; nEntry < COLUMN_COUNT; nEntry++)
				{
					if(pMapping->aColumnPairs[nEntry].sLogicalColumnName == sTypeMapping)
					{
						sTypeMapping = pMapping->aColumnPairs[nEntry].sRealColumnName;
						break;
					}
				}
			}
			rtl::OUString uTypeMapping = sTypeMapping;

			uno::Reference< form::XForm >  xForm = pDatMan->getForm();
			uno::Reference< sdbcx::XColumnsSupplier >  xSupplyCols(xForm, UNO_QUERY);
			uno::Reference< container::XNameAccess >  xValueAcc;
			if (xSupplyCols.is())
				xValueAcc = xSupplyCols->getColumns();

			sal_Int16 nTempVal = -1;
			if(xValueAcc.is() && xValueAcc->hasByName(uTypeMapping))
			{
				uno::Any aVal = xValueAcc->getByName(uTypeMapping);
				uno::Reference< uno::XInterface >  xInt = *(uno::Reference< uno::XInterface > *)aVal.getValue();
				uno::Reference< sdb::XColumn >	xCol(xInt, UNO_QUERY);
				DBG_ASSERT(xCol.is(), "BibPosListener::positioned : invalid column (no sdb::XColumn) !");
				if (xCol.is())
				{
					nTempVal = xCol->getShort();
					// getShort returns zero if the value is not a number
					if (!nTempVal || xCol->wasNull())
					{
						rtl::OUString sTempVal = xCol->getString();
						if(sTempVal != rtl::OUString('0'))
							nTempVal = -1;
					}
				}
			}
			if(nTempVal < 0 || nTempVal >= TYPE_COUNT)
			{
				uno::Any aSel;
				uno::Sequence<sal_Int16> aSelSeq(1);
				sal_Int16* pArr = aSelSeq.getArray();
				pArr[0] = TYPE_COUNT;
				aSel.setValue(&aSelSeq, ::getCppuType((Sequence<sal_Int16>*)0));
				xPropSet->setPropertyValue(C2U("SelectedItems"), aSel);
			}
		}
	}
	catch(Exception& rEx)
	{
		(void) rEx;	// make compiler happy
        DBG_ERROR("BibPosListener::positioned: something went wrong !");
	}
}
/* -----------------------------04.01.00 11:28--------------------------------

 ---------------------------------------------------------------------------*/
void BibPosListener::disposing(const lang::EventObject& /*Source*/) throw( uno::RuntimeException )
{
}

/* -----------------16.11.99 13:06-------------------

 --------------------------------------------------*/
BibGeneralPage::BibGeneralPage(Window* pParent, BibDataManager* pMan):
	BibTabPage(pParent,BibResId(RID_TP_GENERAL)),
	aControlParentWin(this, WB_DIALOGCONTROL),
	aIdentifierFT(&aControlParentWin,	BibResId(FT_IDENTIFIER 	)),
	aAuthTypeFT(&aControlParentWin, 	BibResId(FT_AUTHTYPE		)),
	aYearFT(&aControlParentWin, 		BibResId(FT_YEAR			)),
	aAuthorFT(&aControlParentWin,		BibResId(FT_AUTHOR 		)),
	aTitleFT(&aControlParentWin,		BibResId(FT_TITLE			)),
	aPublisherFT(&aControlParentWin,	BibResId(FT_PUBLISHER		)),
	aAddressFT(&aControlParentWin,		BibResId(FT_ADDRESS		)),
	aISBNFT(&aControlParentWin, 		BibResId(FT_ISBN			)),
	aChapterFT(&aControlParentWin,		BibResId(FT_CHAPTER		)),
	aPagesFT(&aControlParentWin,		BibResId(FT_PAGE			)),
    aFirstFL(&aControlParentWin,        BibResId(FL_1        )),
	aEditorFT(&aControlParentWin,		BibResId(FT_EDITOR 		)),
	aEditionFT(&aControlParentWin,		BibResId(FT_EDITION		)),
	aBooktitleFT(&aControlParentWin,	BibResId(FT_BOOKTITLE		)),
	aVolumeFT(&aControlParentWin,		BibResId(FT_VOLUME 		)),
	aHowpublishedFT(&aControlParentWin, BibResId(FT_HOWPUBLISHED	)),
	aOrganizationsFT(&aControlParentWin,BibResId(FT_ORGANIZATION	)),
	aInstitutionFT(&aControlParentWin,	BibResId(FT_INSTITUTION	)),
	aSchoolFT(&aControlParentWin,		BibResId(FT_SCHOOL 		)),
	aReportTypeFT(&aControlParentWin,	BibResId(FT_REPORT 		)),
	aMonthFT(&aControlParentWin,		BibResId(FT_MONTH			)),
    aSecondFL(&aControlParentWin,       BibResId(FL_2        )),
	aJournalFT(&aControlParentWin,		BibResId(FT_JOURNAL		)),
	aNumberFT(&aControlParentWin,		BibResId(FT_NUMBER 		)),
	aSeriesFT(&aControlParentWin,		BibResId(FT_SERIES 		)),
	aAnnoteFT(&aControlParentWin,		BibResId(FT_ANNOTE 		)),
	aNoteFT(&aControlParentWin, 		BibResId(FT_NOTE			)),
	aURLFT(&aControlParentWin,			BibResId(FT_URL			)),
    aThirdFL(&aControlParentWin,        BibResId(FL_3        )),
	aCustom1FT(&aControlParentWin,		BibResId(FT_CUSTOM1		)),
	aCustom2FT(&aControlParentWin,		BibResId(FT_CUSTOM2		)),
	aCustom3FT(&aControlParentWin,		BibResId(FT_CUSTOM3		)),
	aCustom4FT(&aControlParentWin,		BibResId(FT_CUSTOM4		)),
	aCustom5FT(&aControlParentWin,		BibResId(FT_CUSTOM5		)),
	aHoriScroll(this, WB_HORZ),
	aVertScroll(this, WB_VERT),
	sErrorPrefix(BibResId(ST_ERROR_PREFIX)),
	pDatMan(pMan)
{
	aControlParentWin.Show();
	aControlParentWin.SetHelpId(HID_BIB_CONTROL_PARENT);
	aStdSize = GetOutputSizePixel();

	aBibTypeArr[0] = String(BibResId(ST_TYPE_ARTICLE));
	aBibTypeArr[1] = String(BibResId(ST_TYPE_BOOK));
	aBibTypeArr[2] = String(BibResId(ST_TYPE_BOOKLET));
	aBibTypeArr[3] = String(BibResId(ST_TYPE_CONFERENCE));
	aBibTypeArr[4] = String(BibResId(ST_TYPE_INBOOK	));
	aBibTypeArr[5] = String(BibResId(ST_TYPE_INCOLLECTION));
	aBibTypeArr[6] = String(BibResId(ST_TYPE_INPROCEEDINGS));
	aBibTypeArr[7] = String(BibResId(ST_TYPE_JOURNAL	   ));
	aBibTypeArr[8] = String(BibResId(ST_TYPE_MANUAL	   ));
	aBibTypeArr[9] = String(BibResId(ST_TYPE_MASTERSTHESIS));
	aBibTypeArr[10] = String(BibResId(ST_TYPE_MISC 		));
	aBibTypeArr[11] = String(BibResId(ST_TYPE_PHDTHESIS	));
	aBibTypeArr[12] = String(BibResId(ST_TYPE_PROCEEDINGS	));
	aBibTypeArr[13] = String(BibResId(ST_TYPE_TECHREPORT	));
	aBibTypeArr[14] = String(BibResId(ST_TYPE_UNPUBLISHED	));
	aBibTypeArr[15] = String(BibResId(ST_TYPE_EMAIL		));
	aBibTypeArr[16] = String(BibResId(ST_TYPE_WWW			));
	aBibTypeArr[17] = String(BibResId(ST_TYPE_CUSTOM1		));
	aBibTypeArr[18] = String(BibResId(ST_TYPE_CUSTOM2		));
	aBibTypeArr[19] = String(BibResId(ST_TYPE_CUSTOM3		));
	aBibTypeArr[20] = String(BibResId(ST_TYPE_CUSTOM4		));
	aBibTypeArr[21] = String(BibResId(ST_TYPE_CUSTOM5		));

	FreeResource();

	InitFixedTexts();

	aBasePos = aIdentifierFT.GetPosPixel();

	sal_Int16* pMap = nFT2CtrlMap;
	for( sal_uInt16 i = 0 ; i < FIELD_COUNT ; ++i, ++pMap )
	{
		aControls[ i ] = 0;
		*pMap = -1;
	}

	AdjustScrollbars();
	Link aScrollLnk(LINK(this, BibGeneralPage, ScrollHdl));
	aHoriScroll.SetScrollHdl( aScrollLnk );
	aVertScroll.SetScrollHdl( aScrollLnk );
	aHoriScroll.SetLineSize(10);
	aVertScroll.SetLineSize(10);
	aHoriScroll.SetPageSize( aIdentifierFT.GetSizePixel().Width());
	aVertScroll.SetPageSize(
		aPublisherFT.GetPosPixel().Y() - aIdentifierFT.GetPosPixel().Y());
	aHoriScroll.Show();
	aVertScroll.Show();

	BibConfig* pBibConfig = BibModul::GetConfig();
	BibDBDescriptor aDesc;
	aDesc.sDataSource = pDatMan->getActiveDataSource();
	aDesc.sTableOrQuery = pDatMan->getActiveDataTable();
	aDesc.nCommandType = CommandType::TABLE;
	const Mapping* pMapping = pBibConfig->GetMapping(aDesc);

	xCtrlContnr = VCLUnoHelper::CreateControlContainer(&aControlParentWin);

	xMgr = comphelper::getProcessServiceFactory();
    // the control should be a bit smaller than the fixed text
    Size aControlSize(aIdentifierFT.GetSizePixel());
    aControlSize.Width() = aControlSize.Width() * 8 / 10;
    
    AddControlWithError( lcl_GetColumnName( pMapping, IDENTIFIER_POS ), lcl_MovePoint( aIdentifierFT ),
        aControlSize, sTableErrorString, aIdentifierFT.GetText(),
		HID_BIB_IDENTIFIER_POS, 0 );

	sTypeColumnName = lcl_GetColumnName(pMapping, AUTHORITYTYPE_POS);

    AddControlWithError( sTypeColumnName, lcl_MovePoint(aAuthTypeFT ), aControlSize, sTableErrorString,
		aAuthTypeFT.GetText(), HID_BIB_AUTHORITYTYPE_POS, 1 );

	::Point aYearPos = lcl_MovePoint(aYearFT);
    AddControlWithError( lcl_GetColumnName( pMapping, YEAR_POS ), aYearPos, 
        aControlSize, sTableErrorString, aYearFT.GetText(), HID_BIB_YEAR_POS, 4 );

	AddControlWithError( lcl_GetColumnName(pMapping, AUTHOR_POS), lcl_MovePoint(aAuthorFT),
        aControlSize, sTableErrorString, aAuthorFT.GetText(), HID_BIB_AUTHOR_POS, 2 );

	::Point aTitlePos( lcl_MovePoint( aTitleFT ) );
	::Size aTitleSize = aTitleFT.GetSizePixel();
    aTitleSize.Width() = aYearPos.X() + aControlSize.Width() - aTitlePos.X();
	AddControlWithError( lcl_GetColumnName(pMapping, TITLE_POS), aTitlePos, aTitleSize, sTableErrorString,
		aTitleFT.GetText(), HID_BIB_TITLE_POS, 22 );

	AddControlWithError( lcl_GetColumnName( pMapping, PUBLISHER_POS ), lcl_MovePoint( aPublisherFT),
        aControlSize, sTableErrorString, aPublisherFT.GetText(), HID_BIB_PUBLISHER_POS, 5 );

	AddControlWithError( lcl_GetColumnName( pMapping, ADDRESS_POS ), lcl_MovePoint( aAddressFT ),
        aControlSize, sTableErrorString, aAddressFT.GetText(), HID_BIB_ADDRESS_POS, 7 );

	AddControlWithError( lcl_GetColumnName( pMapping, ISBN_POS ), lcl_MovePoint( aISBNFT ),
        aControlSize, sTableErrorString, aISBNFT.GetText(), HID_BIB_ISBN_POS, 6 );

	AddControlWithError( lcl_GetColumnName( pMapping, CHAPTER_POS ), lcl_MovePoint(aChapterFT),
        aControlSize, sTableErrorString, aChapterFT.GetText(), HID_BIB_CHAPTER_POS, 10 );

    AddControlWithError( lcl_GetColumnName( pMapping, PAGES_POS ), lcl_MovePoint( aPagesFT ), 
        aControlSize, sTableErrorString, aPagesFT.GetText(), HID_BIB_PAGES_POS, 19 );

    AddControlWithError( lcl_GetColumnName( pMapping, EDITOR_POS ), lcl_MovePoint( aEditorFT ), 
        aControlSize, sTableErrorString, aEditorFT.GetText(), HID_BIB_EDITOR_POS, 12 );

    AddControlWithError( lcl_GetColumnName( pMapping, EDITION_POS ), lcl_MovePoint(aEditionFT), 
        aControlSize, sTableErrorString, aEditionFT.GetText(), HID_BIB_EDITION_POS, 11 );

	AddControlWithError( lcl_GetColumnName(pMapping, BOOKTITLE_POS), lcl_MovePoint(aBooktitleFT),
        aControlSize, sTableErrorString, aBooktitleFT.GetText(), HID_BIB_BOOKTITLE_POS, 9 );

    AddControlWithError( lcl_GetColumnName( pMapping, VOLUME_POS ), lcl_MovePoint( aVolumeFT ), 
        aControlSize, sTableErrorString, aVolumeFT.GetText(), HID_BIB_VOLUME_POS, 24 );

	AddControlWithError( lcl_GetColumnName( pMapping, HOWPUBLISHED_POS ), lcl_MovePoint( aHowpublishedFT ),
        aControlSize, sTableErrorString, aHowpublishedFT.GetText(), HID_BIB_HOWPUBLISHED_POS, 13 );

	AddControlWithError( lcl_GetColumnName( pMapping, ORGANIZATIONS_POS ), lcl_MovePoint( aOrganizationsFT ),
        aControlSize, sTableErrorString, aOrganizationsFT.GetText(), HID_BIB_ORGANIZATIONS_POS, 18 );

	AddControlWithError( lcl_GetColumnName( pMapping, INSTITUTION_POS ), lcl_MovePoint( aInstitutionFT ),
        aControlSize, sTableErrorString, aInstitutionFT.GetText(), HID_BIB_INSTITUTION_POS, 14 );

    AddControlWithError( lcl_GetColumnName( pMapping, SCHOOL_POS ), lcl_MovePoint( aSchoolFT ), 
        aControlSize, sTableErrorString, aSchoolFT.GetText(), HID_BIB_SCHOOL_POS, 20 );

	AddControlWithError( lcl_GetColumnName( pMapping, REPORTTYPE_POS ), lcl_MovePoint( aReportTypeFT ),
        aControlSize, sTableErrorString, aReportTypeFT.GetText(), HID_BIB_REPORTTYPE_POS, 23 );

    AddControlWithError( lcl_GetColumnName( pMapping, MONTH_POS ), lcl_MovePoint( aMonthFT ), 
        aControlSize, sTableErrorString, aMonthFT.GetText(), HID_BIB_MONTH_POS, 3 );

	AddControlWithError( lcl_GetColumnName( pMapping, JOURNAL_POS ), lcl_MovePoint( aJournalFT ),
        aControlSize, sTableErrorString, aJournalFT.GetText(), HID_BIB_JOURNAL_POS, 15 );

    AddControlWithError( lcl_GetColumnName( pMapping, NUMBER_POS ), lcl_MovePoint( aNumberFT ), 
        aControlSize, sTableErrorString, aNumberFT.GetText(), HID_BIB_NUMBER_POS, 17 );

    AddControlWithError( lcl_GetColumnName( pMapping, SERIES_POS ), lcl_MovePoint( aSeriesFT ), 
        aControlSize, sTableErrorString, aSeriesFT.GetText(), HID_BIB_SERIES_POS, 21 );

    AddControlWithError( lcl_GetColumnName( pMapping, ANNOTE_POS ), lcl_MovePoint( aAnnoteFT ), 
        aControlSize, sTableErrorString, aAnnoteFT.GetText(), HID_BIB_ANNOTE_POS, 8 );

    AddControlWithError( lcl_GetColumnName( pMapping, NOTE_POS ), lcl_MovePoint( aNoteFT ), 
        aControlSize, sTableErrorString, aNoteFT.GetText(), HID_BIB_NOTE_POS, 16 );

    AddControlWithError( lcl_GetColumnName( pMapping, URL_POS ), lcl_MovePoint( aURLFT ), 
        aControlSize, sTableErrorString, aURLFT.GetText(), HID_BIB_URL_POS, 25 );

	AddControlWithError( lcl_GetColumnName( pMapping, CUSTOM1_POS ), lcl_MovePoint( aCustom1FT ),
        aControlSize, sTableErrorString, aCustom1FT.GetText(), HID_BIB_CUSTOM1_POS, 26 );

    AddControlWithError( lcl_GetColumnName( pMapping, CUSTOM2_POS ), lcl_MovePoint( aCustom2FT ), 
        aControlSize, sTableErrorString, aCustom2FT.GetText(), HID_BIB_CUSTOM2_POS, 27 );

    AddControlWithError( lcl_GetColumnName( pMapping, CUSTOM3_POS ), lcl_MovePoint( aCustom3FT ), 
        aControlSize, sTableErrorString, aCustom3FT.GetText(), HID_BIB_CUSTOM3_POS, 28 );

    AddControlWithError( lcl_GetColumnName( pMapping, CUSTOM4_POS ), lcl_MovePoint( aCustom4FT ), 
        aControlSize, sTableErrorString, aCustom4FT.GetText(), HID_BIB_CUSTOM4_POS, 29 );

    AddControlWithError( lcl_GetColumnName( pMapping, CUSTOM5_POS ), lcl_MovePoint( aCustom5FT ), 
        aControlSize, sTableErrorString, aCustom5FT.GetText(), HID_BIB_CUSTOM5_POS, 30 );

	xPosListener = new BibPosListener(this);
	uno::Reference< sdbc::XRowSet >  xRowSet(pDatMan->getForm(), UNO_QUERY);
	if(xRowSet.is())
		xRowSet->addRowSetListener(xPosListener);
    uno::Reference< form::runtime::XFormController > xFormCtrl = pDatMan->GetFormController();
    xFormCtrl->setContainer(xCtrlContnr);
	xFormCtrl->activateTabOrder();

	if(sTableErrorString.Len())
		sTableErrorString.Insert(sErrorPrefix, 0);
}
//-----------------------------------------------------------------------------
BibGeneralPage::~BibGeneralPage()
{
	if (pDatMan && xPosListener.is())
	{
		uno::Reference< sdbc::XRowSet >  xRowSet(pDatMan->getForm(), UNO_QUERY);
		if(xRowSet.is())
			xRowSet->removeRowSetListener(xPosListener);
	}
}
 /* -----------------------------14.04.00 13:11--------------------------------

  ---------------------------------------------------------------------------*/
 void BibGeneralPage::RemoveListeners()
 {
	for(sal_uInt16 i = 0; i < FIELD_COUNT; i++)
	{
		if(aControls[i].is())
		{
			uno::Reference< awt::XWindow > xCtrWin(aControls[i], uno::UNO_QUERY );
			xCtrWin->removeFocusListener( this );
			aControls[i] = 0;
		}
	}
 }
/* -----------------------------21.01.00 17:05--------------------------------

 ---------------------------------------------------------------------------*/
void BibGeneralPage::CommitActiveControl()
{
    uno::Reference< form::runtime::XFormController > xFormCtrl = pDatMan->GetFormController();
    uno::Reference< awt::XControl >  xCurr = xFormCtrl->getCurrentControl();
	if(xCurr.is())
	{
		uno::Reference< awt::XControlModel >  xModel = xCurr->getModel();
		uno::Reference< form::XBoundComponent >  xBound(xModel, UNO_QUERY);
		if(xBound.is())
			xBound->commit();
	}
}
//-----------------------------------------------------------------------------
void BibGeneralPage::AddControlWithError( const OUString& rColumnName, const ::Point& rPos, const ::Size& rSize,
								String& rErrorString, String aColumnUIName, const rtl::OString& sHelpId, sal_uInt16 nIndexInFTArray )
{
	// adds also the XControl and creates a map entry in nFT2CtrlMap[] for mapping between control and FT

	sal_Int16									nIndex = -1;
	uno::Reference< awt::XControlModel >	xTmp = AddXControl(rColumnName, rPos, rSize, sHelpId, nIndex );
	if( xTmp.is() )
	{
		DBG_ASSERT( nIndexInFTArray < FIELD_COUNT, "*BibGeneralPage::AddControlWithError(): wrong array index!" );
		DBG_ASSERT( nFT2CtrlMap[ nIndexInFTArray ] < 0, "+BibGeneralPage::AddControlWithError(): index already in use!" );

		nFT2CtrlMap[ nIndexInFTArray ] = nIndex;
	}
	else
	{
		if( rErrorString.Len() )
			rErrorString += '\n';

		rErrorString += MnemonicGenerator::EraseAllMnemonicChars( aColumnUIName );
	}
}
//-----------------------------------------------------------------------------
uno::Reference< awt::XControlModel >  BibGeneralPage::AddXControl(
		const String& rName,
		::Point rPos, ::Size rSize, const rtl::OString& sHelpId, sal_Int16& rIndex )
{
	uno::Reference< awt::XControlModel >  xCtrModel;
	try
	{
		sal_Bool bTypeListBox = sTypeColumnName == rName;
		xCtrModel = pDatMan->loadControlModel(rName, bTypeListBox);
		if ( xCtrModel.is() && xMgr.is())
		{
			uno::Reference< beans::XPropertySet >  xPropSet( xCtrModel, UNO_QUERY );

			if( xPropSet.is())
			{
				uno::Reference< beans::XPropertySetInfo >  xPropInfo = xPropSet->getPropertySetInfo();

				uno::Any aAny = xPropSet->getPropertyValue( C2U("DefaultControl") );
				rtl::OUString aControlName;
				aAny >>= aControlName;

				rtl::OUString uProp(C2U("HelpURL"));
				if(xPropInfo->hasPropertyByName(uProp))
				{
			        ::rtl::OUString sId = ::rtl::OUString::createFromAscii( INET_HID_SCHEME );
                    DBG_ASSERT( INetURLObject( rtl::OStringToOUString( sHelpId, RTL_TEXTENCODING_UTF8 ) ).GetProtocol() == INET_PROT_NOT_VALID, "Wrong HelpId!" );
			        sId += ::rtl::OStringToOUString( sHelpId, RTL_TEXTENCODING_UTF8 );
			        xPropSet->setPropertyValue( uProp, makeAny( sId ) );
				}

				if(bTypeListBox)
				{
					//uno::Reference< beans::XPropertySet >  xPropSet(xControl, UNO_QUERY);
					aAny <<= (sal_Int16)1;
					xPropSet->setPropertyValue(C2U("BoundColumn"), aAny);
					ListSourceType eSet = ListSourceType_VALUELIST;
					aAny.setValue( &eSet, ::getCppuType((const ListSourceType*)0) );
					xPropSet->setPropertyValue(C2U("ListSourceType"), aAny);

					uno::Sequence<rtl::OUString> aListSource(TYPE_COUNT);
					rtl::OUString* pListSourceArr = aListSource.getArray();
					//pListSourceArr[0] = C2U("select TypeName, TypeIndex from TypeNms");
					for(sal_uInt16 i = 0; i < TYPE_COUNT; i++)
						pListSourceArr[i] = String::CreateFromInt32(i);
					aAny.setValue(&aListSource, ::getCppuType((uno::Sequence<rtl::OUString>*)0));

					xPropSet->setPropertyValue(C2U("ListSource"), aAny);

					uno::Sequence<rtl::OUString> aValues(TYPE_COUNT + 1);
					rtl::OUString* pValuesArr = aValues.getArray();
					for(sal_uInt16 j = 0; j < TYPE_COUNT; j++)
						pValuesArr[j]  = aBibTypeArr[j];
					// empty string if an invalid value no values is set
					pValuesArr[TYPE_COUNT] = rtl::OUString();

					aAny.setValue(&aValues, ::getCppuType((uno::Sequence<rtl::OUString>*)0));

					xPropSet->setPropertyValue(C2U("StringItemList"), aAny);

					sal_Bool bTrue = sal_True;
					aAny.setValue( &bTrue, ::getBooleanCppuType() );
					xPropSet->setPropertyValue( C2U("Dropdown"), aAny );

					aControlName = C2U("com.sun.star.form.control.ListBox");
					xLBModel = Reference< form::XBoundComponent >(xCtrModel, UNO_QUERY);

				}

				uno::Reference< awt::XControl >  xControl(xMgr->createInstance( aControlName ), UNO_QUERY );
				if ( xControl.is() )
				{
					xControl->setModel( xCtrModel);

					// Peer als Child zu dem FrameWindow
					xCtrlContnr->addControl(rName, xControl);
					uno::Reference< awt::XWindow >	xCtrWin(xControl, UNO_QUERY );
					xCtrWin->addFocusListener( this );
					rIndex = -1;	// -> implies, that not found
					for(sal_uInt16 i = 0; i < FIELD_COUNT; i++)
						if(!aControls[i].is())
						{
							aControls[i] = xCtrWin;
							rIndex = sal_Int16( i );
							break;
						}
					xCtrWin->setVisible( sal_True );
					xControl->setDesignMode( sal_True );
						// initially switch on the desing mode - switch it off _after_ loading the form
						// 17.10.2001 - 93107 - frank.schoenheit@sun.com

					xCtrWin->setPosSize(rPos.X(), rPos.Y(), rSize.Width(),
						rSize.Height(), awt::PosSize::POSSIZE);
				}
			}
		}
	}
	catch(Exception& rEx)
	{
		(void) rEx;	// make compiler happy
        DBG_ERROR("BibGeneralPage::AddXControl: something went wrong !");
	}
	return xCtrModel;
}

void BibGeneralPage::AdjustScrollbars()
{
	long nVertScrollWidth = aVertScroll.GetSizePixel().Width();
	long nHoriScrollHeight = aHoriScroll.GetSizePixel().Height();
	::Size aOutSize(GetOutputSizePixel());
	sal_Bool bHoriVisible = aOutSize.Width() <= aStdSize.Width();
	sal_Bool bVertVisible = (aOutSize.Height()-(bHoriVisible ? nHoriScrollHeight : 0)) <= (aStdSize.Height());
	aHoriScroll.Show(bHoriVisible);
	aVertScroll.Show(bVertVisible);

	if(bHoriVisible)
	{
		::Size aHoriSize(aOutSize.Width() - (bVertVisible ? nVertScrollWidth : 0),
						nHoriScrollHeight);
		aHoriScroll.SetSizePixel(aHoriSize);
		aHoriScroll.SetRange( Range(0, aStdSize.Width()));
		aHoriScroll.SetVisibleSize( aHoriSize.Width()  - (bVertVisible ? nVertScrollWidth : 0));
	}
	if(bVertVisible)
	{
		::Size aVertSize(nHoriScrollHeight, aOutSize.Height() -
											(bHoriVisible ? nHoriScrollHeight : 0));
		aVertScroll.SetSizePixel(aVertSize);
		aVertScroll.SetRange( Range(0, aStdSize.Height()));
		aVertScroll.SetVisibleSize( aVertSize.Height() );
	}

	::Size aSize(8, 8);
	aSize = LogicToPixel(aSize, MapMode(MAP_APPFONT));
	::Size aScrollSize(aOutSize.Width() - aSize.Height(), aSize.Height());
	::Point aScrollPos(0, aOutSize.Height() - aSize.Height());
	aHoriScroll.SetPosSizePixel(aScrollPos, aScrollSize);

	aScrollPos.X() = aOutSize.Width() - aSize.Width();
	aScrollPos.Y() = 0;
	aScrollSize.Width() = aSize.Width();
	aScrollSize.Height() = aOutSize.Height() - aSize.Height();
	aVertScroll.SetPosSizePixel(aScrollPos, aScrollSize);

	::Size aControlParentWinSz(aOutSize);
	if(bHoriVisible)
		aControlParentWinSz.Height() -=  aSize.Height();
	if(bVertVisible)
		aControlParentWinSz.Width() -=	aSize.Width();
	aControlParentWin.SetSizePixel(aControlParentWinSz);
}

void BibGeneralPage::Resize()
{
	AdjustScrollbars();
	ScrollHdl(&aVertScroll);
	ScrollHdl(&aHoriScroll);
	Window::Resize();
}

void BibGeneralPage::InitFixedTexts( void )
{
	String		aFixedStrings[ FIELD_COUNT ] =
	{
		String( BibResId( ST_IDENTIFIER		) ),
		String( BibResId( ST_AUTHTYPE		) ),
		String( BibResId( ST_AUTHOR			) ),
		String( BibResId( ST_TITLE			) ),
		String( BibResId( ST_MONTH			) ),
		String( BibResId( ST_YEAR 			) ),
		String( BibResId( ST_ISBN 			) ),
		String( BibResId( ST_BOOKTITLE		) ),
		String( BibResId( ST_CHAPTER		) ),
		String( BibResId( ST_EDITION		) ),
		String( BibResId( ST_EDITOR			) ),
		String( BibResId( ST_HOWPUBLISHED	) ),
		String( BibResId( ST_INSTITUTION	) ),
		String( BibResId( ST_JOURNAL		) ),
		String( BibResId( ST_NOTE 			) ),
		String( BibResId( ST_ANNOTE			) ),
		String( BibResId( ST_NUMBER			) ),
		String( BibResId( ST_ORGANIZATION	) ),
		String( BibResId( ST_PAGE 			) ),
		String( BibResId( ST_PUBLISHER		) ),
		String( BibResId( ST_ADDRESS		) ),
		String( BibResId( ST_SCHOOL			) ),
		String( BibResId( ST_SERIES			) ),
		String( BibResId( ST_REPORT			) ),
		String( BibResId( ST_VOLUME			) ),
		String( BibResId( ST_URL			) ),
		String( BibResId( ST_CUSTOM1		) ),
		String( BibResId( ST_CUSTOM2		) ),
		String( BibResId( ST_CUSTOM3		) ),
		String( BibResId( ST_CUSTOM4		) ),
		String( BibResId( ST_CUSTOM5		) )
	};

	aFixedTexts[0] = &aIdentifierFT;
	aFixedTexts[1] = &aAuthTypeFT;
	aFixedTexts[2] = &aAuthorFT;
	aFixedTexts[3] = &aTitleFT;
	aFixedTexts[4] = &aMonthFT;
	aFixedTexts[5] = &aYearFT;
	aFixedTexts[6] = &aISBNFT;
	aFixedTexts[7] = &aBooktitleFT;
	aFixedTexts[8] = &aChapterFT;
	aFixedTexts[9] = &aEditionFT;
	aFixedTexts[10] = &aEditorFT;
	aFixedTexts[11] = &aHowpublishedFT;
	aFixedTexts[12] = &aInstitutionFT;
	aFixedTexts[13] = &aJournalFT;
	aFixedTexts[14] = &aNoteFT;
	aFixedTexts[15] = &aAnnoteFT;
	aFixedTexts[16] = &aNumberFT;
	aFixedTexts[17] = &aOrganizationsFT;
	aFixedTexts[18] = &aPagesFT;
	aFixedTexts[19] = &aPublisherFT;
	aFixedTexts[20] = &aAddressFT;
	aFixedTexts[21] = &aSchoolFT;
	aFixedTexts[22] = &aSeriesFT;
	aFixedTexts[23] = &aReportTypeFT;
	aFixedTexts[24] = &aVolumeFT;
	aFixedTexts[25] = &aURLFT;
	aFixedTexts[26] = &aCustom1FT;
	aFixedTexts[27] = &aCustom2FT;
	aFixedTexts[28] = &aCustom3FT;
	aFixedTexts[29] = &aCustom4FT;
	aFixedTexts[30] = &aCustom5FT;

	int					i;

	MnemonicGenerator	aMnemonicGenerator;
	// init mnemonics, first register all strings
	for( i = 0 ; i < FIELD_COUNT ; ++i )
		aMnemonicGenerator.RegisterMnemonic( aFixedStrings[ i ] );

	// ... then get all strings
	for( i = 0 ; i < FIELD_COUNT ; ++i )
		aMnemonicGenerator.CreateMnemonic( aFixedStrings[ i ] );

	// set texts
	for( i = 0 ; i < FIELD_COUNT ; ++i )
		aFixedTexts[ i ]->SetText( aFixedStrings[ i ] );
}

IMPL_LINK(BibGeneralPage, ScrollHdl, ScrollBar*, pScroll)
{
	sal_Bool bVertical = &aVertScroll == pScroll;
	long nOffset = 0;
	long nCurrentOffset = 0;
	if(bVertical)
		nCurrentOffset = aFixedTexts[0]->GetPosPixel().Y() - aBasePos.Y();
	else
		nCurrentOffset = aFixedTexts[0]->GetPosPixel().X() - aBasePos.X();
	nOffset = pScroll->IsVisible() ? pScroll->GetThumbPos() + nCurrentOffset : nCurrentOffset;;

	for(sal_uInt16 i = 0; i < FIELD_COUNT; i++)
	{
		::Point aPos = aFixedTexts[i]->GetPosPixel();
		if(bVertical)
			aPos.Y() -= nOffset;
		else
			aPos.X() -= nOffset;
		aFixedTexts[i]->SetPosPixel(aPos);
		if(aControls[i].is())
		{
			awt::Rectangle aRect = aControls[i]->getPosSize();
			long nX = aRect.X;
			long nY = aRect.Y;
			if(bVertical)
				nY -= nOffset;
			else
				nX -= nOffset;
			aControls[i]->setPosSize(nX, nY, 0, 0, awt::PosSize::POS);
		}
	}
	return 0;
}

void BibGeneralPage::focusGained(const awt::FocusEvent& rEvent) throw( uno::RuntimeException )
{
	Reference<awt::XWindow> xCtrWin(rEvent.Source, UNO_QUERY );
	if(xCtrWin.is())
	{
		::Size aOutSize = aControlParentWin.GetOutputSizePixel();
		awt::Rectangle aRect = xCtrWin->getPosSize();
		long nX = aRect.X;
		if(nX < 0)
		{
			// left of the visible area
			aHoriScroll.SetThumbPos(aHoriScroll.GetThumbPos() + nX);
			ScrollHdl(&aHoriScroll);
		}
		else if(nX > aOutSize.Width())
		{
			// right of the visible area
			aHoriScroll.SetThumbPos(aHoriScroll.GetThumbPos() + nX - aOutSize.Width() + aFixedTexts[0]->GetSizePixel().Width());
			ScrollHdl(&aHoriScroll);
		}
		long nY = aRect.Y;
		if(nY < 0)
		{
			// below the visible area
			aVertScroll.SetThumbPos(aVertScroll.GetThumbPos() + nY);
			ScrollHdl(&aVertScroll);
		}
		else if(nY > aOutSize.Height())
		{
			// over the visible area
			aVertScroll.SetThumbPos(aVertScroll.GetThumbPos() + nY - aOutSize.Height()+ aFixedTexts[0]->GetSizePixel().Height());
			ScrollHdl(&aVertScroll);
		}
	}
}

void BibGeneralPage::focusLost(const awt::FocusEvent& ) throw( uno::RuntimeException )
{
	CommitActiveControl();
}

void BibGeneralPage::disposing(const lang::EventObject& /*Source*/) throw( uno::RuntimeException )
{
}

void BibGeneralPage::GetFocus()
{
	Reference< awt::XWindow >*	pxControl = aControls;

	for( int i = FIELD_COUNT ; i ; --i, ++pxControl )
	{
		if( pxControl->is() )
		{
			( *pxControl )->setFocus();
			return;
		}
	}

	// fallback
	aControlParentWin.GrabFocus();
}

sal_Bool BibGeneralPage::HandleShortCutKey( const KeyEvent& rKeyEvent )
{
	DBG_ASSERT( KEY_MOD2 == rKeyEvent.GetKeyCode().GetModifier(), "+BibGeneralPage::HandleShortCutKey(): this is not for me!" );

    const vcl::I18nHelper&		rI18nHelper = Application::GetSettings().GetUILocaleI18nHelper();
	const xub_Unicode			c = rKeyEvent.GetCharCode();
	sal_Bool						bHandled = sal_False;

	sal_Int16					i;

	typedef std::vector< sal_Int16 >	sal_Int16_vector;

	sal_Int16_vector::size_type	nFocused = 0xFFFF;	// index of focused in vector, no one focused initial
	DBG_ASSERT( nFocused > 0, "*BibGeneralPage::HandleShortCutKey(): size_type works not as expected!" );

	sal_Int16_vector			aMatchList;

	for( i = 0 ; i < FIELD_COUNT ; ++i )
	{
		if( rI18nHelper.MatchMnemonic( aFixedTexts[ i ]->GetText(), c ) )
		{
			bHandled = sal_True;
			sal_Int16			nCtrlIndex = nFT2CtrlMap[ i ];

			if( nCtrlIndex >= 0 )
			{	// store index of control
				DBG_ASSERT( aControls[ nCtrlIndex ].is(), "-BibGeneralPage::HandleShortCutKey(): valid index and no control?" );

				uno::Reference< awt::XControl >  xControl( aControls[ nCtrlIndex ], UNO_QUERY );
				DBG_ASSERT( xControl.is(), "-BibGeneralPage::HandleShortCutKey(): a control which is not a control!" );

				Window*			pWindow = VCLUnoHelper::GetWindow( xControl->getPeer() );

				if( pWindow )
				{
					aMatchList.push_back( nCtrlIndex );
					if( pWindow->HasChildPathFocus() )
					{	// save focused control
						DBG_ASSERT( nFocused == 0xFFFF, "+BibGeneralPage::HandleShortCutKey(): more than one with focus?!" );
						DBG_ASSERT( aMatchList.size() > 0, "+BibGeneralPage::HandleShortCutKey(): push_back and no content?!" );
						nFocused = aMatchList.size() - 1;
					}
				}
			}
		}
	}

	if( bHandled )
	{
		DBG_ASSERT( aMatchList.size() > 0, "*BibGeneralPage::HandleShortCutKey(): be prepared to crash..." );

		if( nFocused >= ( aMatchList.size() - 1 ) )
			// >=... includes 0xFFFF
			// no one or last focused, take first
			nFocused = 0;
		else
			// take next one
			nFocused++;

		aControls[ aMatchList[ nFocused ] ]->setFocus();
	}

	return bHandled;
}