/*************************************************************************
 *
 *  $RCSfile: fmtfield.hxx,v $
 *
 *  $Revision: 1.8 $
 *
 *  last change: $Author: hr $ $Date: 2003/03/27 14:36:12 $
 *
 *  The Contents of this file are made available subject to the terms of
 *  either of the following licenses
 *
 *         - GNU Lesser General Public License Version 2.1
 *         - Sun Industry Standards Source License Version 1.1
 *
 *  Sun Microsystems Inc., October, 2000
 *
 *  GNU Lesser General Public License Version 2.1
 *  =============================================
 *  Copyright 2000 by Sun Microsystems, Inc.
 *  901 San Antonio Road, Palo Alto, CA 94303, USA
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License version 2.1, as published by the Free Software Foundation.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *  MA  02111-1307  USA
 *
 *
 *  Sun Industry Standards Source License Version 1.1
 *  =================================================
 *  The contents of this file are subject to the Sun Industry Standards
 *  Source License Version 1.1 (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.openoffice.org/license.html.
 *
 *  Software provided under this License is provided on an "AS IS" basis,
 *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
 *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
 *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
 *  See the License for the specific provisions governing your rights and
 *  obligations concerning the Software.
 *
 *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
 *
 *  Copyright: 2000 by Sun Microsystems, Inc.
 *
 *  All Rights Reserved.
 *
 *  Contributor(s): _______________________________________
 *
 *
 ************************************************************************/

#ifndef _FMTFIELD_HXX_
#define _FMTFIELD_HXX_

#ifndef _SV_SPINFLD_HXX //autogen
#include <vcl/spinfld.hxx>
#endif

#ifndef _ZFORLIST_HXX //autogen
#include <svtools/zforlist.hxx>
#endif

//#define REGEXP_SUPPORT

#ifdef REGEXP_SUPPORT
	#ifndef _UNOTOOLS_TEXTSEARCH_HXX
	#include <unotools/textsearch.hxx>
	#endif
#else
	// use a hand-made regular expression parsing for the small expression we're interested in
	// as soon as OOo does have regular expression support, we can switch on the REGEXP_SUPPORT define
	namespace validation { class NumberValidator; }
#endif

typedef USHORT FORMAT_CHANGE_TYPE;
#define FCT_KEYONLY			0x00		// only a new key was set
#define FCT_FORMATTER		0x01		// a new formatter weas set, usually implies a change of the key, too
#define FCT_PRECISION		0x02		// a new precision was set
#define FCT_THOUSANDSSEP	0x03		// the thousands separator setting changed

//------------------------------------------------------------------------------
class FormattedField : public SpinField
{
private:
	// Da ein SvNumberFormatter eine ziemlich teure (sowohl zeit- als auch platz-maessig) Angelegenheit ist,
	// haelt sich nicht jedes Field, an dem kein Formatter gesetzt wurde, eine eigenen Instanz, sondern es gibt nur eine
	// einzige statische.
	class StaticFormatter
	{
		static SvNumberFormatter*	s_cFormatter;
		static ULONG				s_nReferences;
	public:
		StaticFormatter();
		~StaticFormatter();

		operator SvNumberFormatter* () { return GetFormatter(); }
		SvNumberFormatter* GetFormatter();
	};

protected:
	String		m_sLastValidText;
		// hat nichts mit dem current value zu tun, ist der letzte Text, der waehrend einer Eingabe als gueltig erkannt
		// wurde (also durch CheckText geprueft, nicht durch den Formatter gejagt)
	Selection	m_aLastSelection;

	double				m_dMinValue;
	double				m_dMaxValue;
	BOOL				m_bHasMin : 1;
	BOOL				m_bHasMax : 1;

	BOOL				m_bStrictFormat : 1;

	BOOL				m_bValueDirty : 1;
	BOOL				m_bEnableEmptyField : 1;
	BOOL				m_bAutoColor : 1;
	double				m_dCurrentValue;
	double				m_dDefaultValue;

	ULONG				m_nFormatKey;
	SvNumberFormatter*	m_pFormatter;
	StaticFormatter		m_aStaticFormatter;

	double				m_dSpinSize;
	double				m_dSpinFirst;
	double				m_dSpinLast;

	// es macht einen Unterschied, ob man bei eingestellter Textformatierung beim LostFocus den aktuellen String durch
	// den Formatter jagt und das Ergebnis anzeigt oder erst aus dem String ein double macht, das formatiert und dann
	// ausgibt
	BOOL				m_bTreatAsNumber;
	// und mit den folgenden Members koennen wir das Ganze hier auch zur formatierten Text-Ausgabe benutzen ...
	String				m_sCurrentTextValue;
	String				m_sDefaultText;

	// die bei der letzten Ausgabe-Operation vom Formatter gelieferte Farbe (nicht dass wir sie beachten wuerden, aber
	// man kann sie von aussen abfragen)
	Color*				m_pLastOutputColor;

public:
	FormattedField(Window* pParent, WinBits nStyle = 0, SvNumberFormatter* pInitialFormatter = NULL, INT32 nFormatKey = 0);
	FormattedField(Window* pParent, const ResId& rResId, SvNumberFormatter* pInitialFormatter = NULL, INT32 nFormatKey = 0);
	virtual ~FormattedField();

	// Min-/Max-Verwaltung
	BOOL	HasMinValue() const			{ return m_bHasMin; }
	void	ClearMinValue()				{ m_bHasMin = FALSE; }
	void	SetMinValue(double dMin);
	double	GetMinValue() const			{ return m_dMinValue; }

	BOOL	HasMaxValue() const			{ return m_bHasMax; }
	void	ClearMaxValue()				{ m_bHasMax = FALSE; }
	void	SetMaxValue(double dMax);
	double	GetMaxValue() const			{ return m_dMaxValue; }

	// aktueller Wert
	virtual void	SetValue(double dVal);
	virtual double	GetValue();
		// die Standard-Implementierung jagt die Eingabe jeweils durch den Formatter, so einer vorhanden ist

	void	GetColor() const;

	void	SetTextValue(const XubString& rText);
		// der String wird in ein double umgewandelt (durch den Formatter) und anschliessen in SetValue gesteckt

	BOOL	IsEmptyFieldEnabled() const			{ return m_bEnableEmptyField; }
	void	EnableEmptyField(BOOL bEnable);
		// wenn nicht enabled, wird beim Verlassen des Feldes der Text auf den letzten gueltigen zurueckgesetzt

	void	SetDefaultValue(double dDefault)	{ m_dDefaultValue = dDefault; m_bValueDirty = TRUE; }
		// wenn der aktuelle String ungueltig ist, liefert GetValue() diesen Default-Wert
	double	GetDefaultValue() const				{ return m_dDefaultValue; }

	// Einstellungen fuer das Format
	ULONG	GetFormatKey() const				{ return m_nFormatKey; }
	void	SetFormatKey(ULONG nFormatKey);

	SvNumberFormatter*	GetFormatter() const	{ return m_pFormatter; }
	void	SetFormatter(SvNumberFormatter* pFormatter, BOOL bResetFormat = TRUE);
		// wenn bResetFormat FALSE ist, wird versucht, das alte eingestellte Format mit 'hinueberzuretten' (teuer, wenn es sich nicht
		// um eines der Standard-Formate handelt, die in allen Formattern gleich sind)
		// wenn TRUE, wird als neuer FormatKey 0 gesetzt

	BOOL	GetThousandsSep() const;
	void	SetThousandsSep(BOOL _bUseSeparator);
		// the is no check if the current format is numeric, so be cautious when calling these functions

	USHORT	GetDecimalDigits() const;
	void	SetDecimalDigits(USHORT _nPrecision);
		// the is no check if the current format is numeric, so be cautious when calling these functions

	SvNumberFormatter*	StandardFormatter() { return m_aStaticFormatter; }
		// Wenn man keinen eigenen Formatter explizit anlegen will, kann man diesen hier in SetFormatter stecken ...
		// Das hier gelieferte Objekt wird allerdings zwischen allen Instanzen der Klasse geteilt (aus Zeit- und Platzgruenden),
		// also ist etwas Vorsicht angebracht ...

	void		GetFormat(XubString& rFormatString, LanguageType& eLang) const;
	BOOL		SetFormat(const XubString& rFormatString, LanguageType eLang);
		// FALSE, wenn der FormatString nicht gesetzt werden konnte (also wahrscheinlich ungueltig ist)

	BOOL	IsStrictFormat() const				{ return m_bStrictFormat; }
	void	SetStrictFormat(BOOL bEnable)		{ m_bStrictFormat = bEnable; }
		// Formatueberpruefung waehrend der Eingabe ?

	// Spin-Handling
	virtual void Up();
	virtual void Down();
		// Standard-Implementierung : hoch- oder runterzaehlen des aktuellen double einfach um die gesetzte SpinSize
	virtual void First();
	virtual void Last();
		// Standard-Implementierung : aktuelles double setzen auf eingestellten first respektive last value

	void	SetSpinSize(double dStep)	{ m_dSpinSize = dStep; }
	double	GetSpinSize() const			{ return m_dSpinSize; }

	void	SetSpinFirst(double dFirst)	{ m_dSpinFirst = dFirst; }
	double	GetSpinFirst() const		{ return m_dSpinFirst; }

	void	SetSpinLast(double dLast)	{ m_dSpinLast = dLast; }
	double	GetSpinLast() const			{ return m_dSpinLast; }

	BOOL	TreatingAsNumber() const	{ return m_bTreatAsNumber; }
	void	TreatAsNumber(BOOL bDoSo) { m_bTreatAsNumber = bDoSo; }

public:
	virtual void SetText(const XubString& rStr);
	void	SetValidateText(const XubString& rText, const String* pErrorText = NULL);

	// die folgenden Methoden sind interesant, wenn m_bTreatAsNumber auf FALSE sitzt
	/**	nehmen wir mal an, irgendjemand will das ganze schoene double-Handling gar nicht haben, sondern
		einfach den Text formatiert ausgeben ...
		(der Text wird einfach nur durch den Formatter gejagt und dann gesetzt)
	*/
	void SetTextFormatted(const XubString& rText);
	String	GetTextValue() const;

	void	SetDefaultText(const XubString& rDefault) { m_sDefaultText = rDefault; }
	String	GetDefaultText() const { return m_sDefaultText; }

	// die bei der letzten Ausgabe-Operation vom Formatter gelieferte Farbe (Ausgabe-Operationen werden getriggert durch
	// SetValue, SetTextValue, SetTextFormatted, also indirekt eventuell auch durch SetMin-/-MaxValue)
	Color*	GetLastOutputColor() const { return m_pLastOutputColor; }

	/** reformats the current text. Interesting if the user entered some text in an "input format", and
		this should be formatted in the "output format" (which may differ, e.g. by additional numeric
		digits or such).
	*/
	void	Commit();

	// enable automatic coloring. if set to TRUE, and the format the field is working with for any current value
	// says that it has to be painted in a special color (e.g. a format where negative numbers should be printed
	// red), the text is painted with that color automatically.
	// The color used is the same as returned by GetLastOutputColor()
	void	SetAutoColor(BOOL _bAutomatic);
	BOOL	GetAutoColor() const { return m_bAutoColor; }

protected:
	virtual long Notify(NotifyEvent& rNEvt);
	virtual void Modify();

	// CheckText ueberschreiben fuer Ueberpruefung zur Eingabezeit
	virtual BOOL CheckText(const XubString& sText) const { return TRUE; }

	// any aspect of the current format has changed
	virtual void FormatChanged(FORMAT_CHANGE_TYPE nWhat);

	void ImplSetText(const XubString& rNew, Selection* pNewSel);
	void ImplSetValue(double dValue, BOOL bForce);
	BOOL ImplGetValue(double& dNewVal);

	void ImplSetFormatKey(ULONG nFormatKey);
		// SetFormatKey without FormatChanged notification

	virtual SvNumberFormatter*	CreateFormatter() { SetFormatter(StandardFormatter()); return m_pFormatter; }
	SvNumberFormatter*	ImplGetFormatter() const { return m_pFormatter ? m_pFormatter : ((FormattedField*)this)->CreateFormatter(); }

	long PreNotify(NotifyEvent& rNEvt);

	virtual void ReFormat();
};

//------------------------------------------------------------------------------
class DoubleNumericField : public FormattedField
{
protected:
#ifdef REGEXP_SUPPORT
	::utl::TextSearch*				m_pConformanceTester;
#else
	validation::NumberValidator*	m_pNumberValidator;
#endif

public:
	DoubleNumericField(Window* pParent, WinBits nStyle = 0)
		:FormattedField(pParent, nStyle)
#ifdef REGEXP_SUPPORT
		,m_pConformanceTester( NULL )
#else
		,m_pNumberValidator( NULL )
#endif
	{
	}

	DoubleNumericField(Window* pParent, const ResId& rResId)
		:FormattedField(pParent, rResId)
#ifdef REGEXP_SUPPORT
		,m_pConformanceTester( NULL )
#else
		,m_pNumberValidator( NULL )
#endif
	{
	}
	virtual ~DoubleNumericField();

protected:
	virtual BOOL CheckText(const XubString& sText) const;

	virtual void FormatChanged(FORMAT_CHANGE_TYPE nWhat);
	void ResetConformanceTester();
};

//==============================================================================
#define FCT_CURRENCY_SYMBOL		0x10
#define FCT_CURRSYM_POSITION	0x20

//------------------------------------------------------------------------------
class DoubleCurrencyField : public FormattedField
{
	XubString	m_sCurrencySymbol;
	BOOL		m_bPrependCurrSym;
	BOOL		m_bChangingFormat;

public:
	DoubleCurrencyField(Window* pParent, WinBits nStyle = 0);
	DoubleCurrencyField(Window* pParent, const ResId& rResId);

	XubString	getCurrencySymbol() const { return m_sCurrencySymbol; }
	void		setCurrencySymbol(const XubString& _sSymbol);

	BOOL		getPrependCurrSym() const { return m_bPrependCurrSym; }
	void		setPrependCurrSym(BOOL _bPrepend);

protected:
	virtual void FormatChanged(FORMAT_CHANGE_TYPE nWhat);

	void UpdateCurrencyFormat();
};

#endif // _FMTFIELD_HXX_

