Finish rename from prior commit

1 files changed, 2724 insertions, 0 deletions

diff --git a/libtdeedu/extdate/extdatetimeedit.cpp b/libtdeedu/extdate/extdatetimeedit.cpp
new file mode 100644
index 00000000..796bd858
--- /dev/null
+++ b/libtdeedu/extdate/extdatetimeedit.cpp
@@ -0,0 +1,2724 @@
+/****************************************************************************
+**
+**
+** Implementation of date and time edit classes
+**
+** Created : 001103
+**
+** Original qatetimeedit.cpp Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
+**>> ExtDate modifications (C) 2004 Jason Harris <jharris@30doradus.org>
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+**********************************************************************/
+
+//DEBUG
+#include <kdebug.h>
+
+#include "extdatetimeedit.h"
+
+#ifndef TQT_NO_DATETIMEEDIT
+
+//#include "../kernel/tqinternal_p.h"
+//#include "../kernel/tqrichtext_p.h"
+#include <tqinternal_p.h>
+#include <tqrichtext_p.h>
+#include <tqrangecontrol.h>
+#include <tqapplication.h>
+#include <tqpixmap.h>
+#include <tqapplication.h>
+#include <tqvaluelist.h>
+#include <tqstring.h>
+#include <tqstyle.h>
+#include <tqdatetimeedit.h> //need for TQTimeEdit
+
+#define EXTDATETIMEEDIT_HIDDEN_CHAR '0'
+
+static TQString	*lDateSep = 0;
+static TQString	*lTimeSep = 0;
+static bool	lAMPM	  = FALSE;
+static TQString	*lAM	  = 0;
+static TQString	*lPM	  = 0;
+static ExtDateEdit::Order	lOrder = ExtDateEdit::YMD;
+static int refcount = 0;
+
+static void cleanup()
+{
+    delete lDateSep;
+    lDateSep = 0;
+    delete lTimeSep;
+    lTimeSep = 0;
+    delete lAM;
+    lAM = 0;
+    delete lPM;
+    lPM = 0;
+}
+
+/*!
+\internal
+try to get the order of DMY and the date/time separator from the locale settings
+*/
+static void readLocaleSettings()
+{
+    int dpos, mpos, ypos;
+    cleanup();
+
+    lDateSep = new TQString();
+    lTimeSep = new TQString();
+
+#if defined(TQ_WS_WIN)
+    TQT_WA( {
+	TCHAR data[10];
+	GetLocaleInfo( LOCALE_USER_DEFAULT, LOCALE_SDATE, data, 10 );
+	*lDateSep = TQString::fromUcs2( (ushort*)data );
+	GetLocaleInfo( LOCALE_USER_DEFAULT, LOCALE_STIME, data, 10 );
+	*lTimeSep = TQString::fromUcs2( (ushort*)data );
+	GetLocaleInfo( LOCALE_USER_DEFAULT, LOCALE_ITIME, data, 10 );
+	lAMPM = TQString::fromUcs2( (ushort*)data ).toInt()==0;
+	GetLocaleInfo( LOCALE_USER_DEFAULT, LOCALE_S1159, data, 10 );
+	TQString am = TQString::fromUcs2( (ushort*)data );
+	if ( !am.isEmpty() )
+	    lAM = new TQString( am );
+	GetLocaleInfo( LOCALE_USER_DEFAULT, LOCALE_S2359, data, 10 );
+	TQString pm = TQString::fromUcs2( (ushort*)data );
+	if ( !pm.isEmpty()  )
+	    lPM = new TQString( pm );
+    } , {
+	char data[10];
+	GetLocaleInfoA( LOCALE_USER_DEFAULT, LOCALE_SDATE, (char*)&data, 10 );
+	*lDateSep = TQString::fromLocal8Bit( data );
+	GetLocaleInfoA( LOCALE_USER_DEFAULT, LOCALE_STIME, (char*)&data, 10 );
+	*lTimeSep = TQString::fromLocal8Bit( data );
+	GetLocaleInfoA( LOCALE_USER_DEFAULT, LOCALE_ITIME, (char*)&data, 10 );
+	lAMPM = TQString::fromLocal8Bit( data ).toInt()==0;
+	GetLocaleInfoA( LOCALE_USER_DEFAULT, LOCALE_S1159, (char*)&data, 10 );
+	TQString am = TQString::fromLocal8Bit( data );
+	if ( !am.isEmpty() )
+	    lAM = new TQString( am );
+	GetLocaleInfoA( LOCALE_USER_DEFAULT, LOCALE_S2359, (char*)&data, 10 );
+	TQString pm = TQString::fromLocal8Bit( data );
+	if ( !pm.isEmpty() )
+	    lPM = new TQString( pm );
+    } );
+#else
+    *lDateSep = "-";
+    *lTimeSep = ":";
+#endif
+    TQString d = ExtDate( 1999, 11, 22 ).toString( Qt::LocalDate );
+    dpos = d.find( "22" );
+    mpos = d.find( "11" );
+    ypos = d.find( "99" );
+    if ( dpos > -1 && mpos > -1 && ypos > -1 ) {
+	// test for DMY, MDY, YMD, YDM
+	if ( dpos < mpos && mpos < ypos ) {
+	    lOrder = ExtDateEdit::DMY;
+	} else if ( mpos < dpos && dpos < ypos ) {
+	    lOrder = ExtDateEdit::MDY;
+	} else if ( ypos < mpos && mpos < dpos ) {
+	    lOrder = ExtDateEdit::YMD;
+	} else if ( ypos < dpos && dpos < mpos ) {
+	    lOrder = ExtDateEdit::YDM;
+	} else {
+	    // cannot determine the dateformat - use the default
+	    return;
+	}
+
+	// this code needs to change if new formats are added
+
+#ifndef TQ_WS_WIN
+	TQString sep = d.mid( TQMIN( dpos, mpos ) + 2, TQABS( dpos - mpos ) - 2 );
+	if ( d.contains( sep ) == 2 ) {
+	    *lDateSep = sep;
+	}
+#endif
+    }
+
+#ifndef TQ_WS_WIN
+    TQString t = TQTime( 11, 22, 33 ).toString( Qt::LocalDate );
+    dpos = t.find( "11" );
+    mpos = t.find( "22" );
+    ypos = t.find( "33" );
+    // We only allow hhmmss
+    if ( dpos > -1 && dpos < mpos && mpos < ypos ) {
+	TQString sep = t.mid( dpos + 2, mpos - dpos - 2 );
+	if ( sep == t.mid( mpos + 2, ypos - mpos - 2 ) ) {
+	    *lTimeSep = sep;
+	}
+    }
+#endif
+}
+
+static ExtDateEdit::Order localOrder() {
+    if ( !lDateSep ) {
+	readLocaleSettings();
+    }
+    return lOrder;
+}
+
+static TQString localDateSep() {
+    if ( !lDateSep ) {
+	readLocaleSettings();
+    }
+    return *lDateSep;
+}
+
+static TQString localTimeSep() {
+    if ( !lTimeSep ) {
+	readLocaleSettings();
+    }
+    return *lTimeSep;
+}
+
+class ExtDateTimeEditorPrivate
+{
+public:
+    ExtDateTimeEditorPrivate()
+	: frm( TRUE ),
+	  parag( new TQTextParagraph( 0, 0, 0, FALSE ) ),
+	  focusSec(0)
+    {
+	parag->formatter()->setWrapEnabled( FALSE );
+	cursor = new TQTextCursor( 0 );
+	cursor->setParagraph( parag );
+	offset = 0;
+	sep = localDateSep();
+	refcount++;
+    }
+    ~ExtDateTimeEditorPrivate()
+    {
+	delete parag;
+	delete cursor;
+	if ( !--refcount )
+	    cleanup();
+    }
+
+    void appendSection( const TQNumberSection& sec )
+    {
+	sections.append( sec );
+
+    }
+    void clearSections()
+    {
+	sections.clear();
+    }
+    void setSectionSelection( int sec, int selstart, int selend )
+    {
+	if ( sec < 0 || sec > (int)sections.count() )
+	    return;
+	sections[sec].setSelectionStart( selstart );
+	sections[sec].setSelectionEnd( selend );
+    }
+    uint sectionCount() const { return (uint)sections.count(); }
+    void setSeparator( const TQString& s ) { sep = s; }
+    TQString separator() const { return sep; }
+
+    void setFrame( bool f ) { frm = f; }
+    bool frame() const { return frm; }
+
+    int focusSection() const { return focusSec; }
+    int section( const TQPoint& p )
+    {
+	cursor->place( p + TQPoint( offset, 0 ), parag );
+	int idx = cursor->index();
+	for ( uint i = 0; i < sections.count(); ++i ) {
+	    if ( idx >= sections[i].selectionStart() &&
+		 idx <= sections[i].selectionEnd() )
+		return i;
+	}
+	return -1;
+    }
+    TQNumberSection section( int idx ) const
+    {
+	return sections[idx];
+    }
+    bool setFocusSection( int idx )
+    {
+	if ( idx > (int)sections.count()-1 || idx < 0 )
+	    return FALSE;
+	if ( idx != focusSec ) {
+	    focusSec = idx;
+	    applyFocusSelection();
+	    return TRUE;
+	}
+	return FALSE;
+    }
+
+    bool inSectionSelection( int idx )
+    {
+	for ( uint i = 0; i < sections.count(); ++i ) {
+	    if ( idx >= sections[i].selectionStart() &&
+		 idx <= sections[i].selectionEnd() )
+		return TRUE;
+	}
+	return FALSE;
+    }
+
+    void paint( const TQString& txt, bool focus, TQPainter& p,
+		const TQColorGroup& cg, const TQRect& rect, TQStyle& style )
+    {
+	int fw = 0;
+	if ( frm )
+	    fw = style.tqpixelMetric(TQStyle::PM_DefaultFrameWidth);
+
+	parag->truncate( 0 );
+	parag->append( txt );
+	if ( !focus )
+	    parag->removeSelection( TQTextDocument::Standard );
+	else {
+	    applyFocusSelection();
+	}
+
+	/* color all EXTDATETIMEEDIT_HIDDEN_CHAR chars to background color */
+	TQTextFormat *fb = parag->formatCollection()->format( p.font(),
+							     cg.base() );
+	TQTextFormat *nf = parag->formatCollection()->format( p.font(),
+							     cg.text() );
+	for ( uint i = 0; i < txt.length(); ++i ) {
+	    parag->setFormat( i, 1, nf );
+	    if ( inSectionSelection( i ) )
+		continue;
+	    if ( txt.at(i) == EXTDATETIMEEDIT_HIDDEN_CHAR )
+		parag->setFormat( i, 1, fb );
+	    else
+		parag->setFormat( i, 1, nf );
+	}
+	fb->removeRef();
+	nf->removeRef();
+
+	TQRect r( rect.x(), rect.y(), rect.width() - 2 * ( 2 + fw ), rect.height() );
+	parag->pseudoDocument()->docRect = r;
+	parag->tqinvalidate(0);
+	parag->format();
+
+	int xoff = 2 + fw - offset;
+	int yoff = ( rect.height() - parag->rect().height() + 1 ) / 2;
+	if ( yoff < 0 )
+	    yoff = 0;
+
+	p.translate( xoff, yoff );
+	parag->paint( p, cg, 0, TRUE );
+	if ( frm )
+	    p.translate( -xoff, -yoff );
+    }
+
+    void resize( const TQSize& size ) { sz = size; }
+
+    int mapSection( int sec )
+    {
+	return sections[sec].index();
+    }
+
+protected:
+    void applyFocusSelection()
+    {
+	if ( focusSec > -1 ) {
+	    int selstart = sections[ focusSec ].selectionStart();
+	    int selend = sections[ focusSec ].selectionEnd();
+	    parag->setSelection( TQTextDocument::Standard, selstart, selend );
+	    parag->format();
+	    if ( parag->at( selstart )->x < offset ||
+		 parag->at( selend )->x + parag->string()->width( selend ) > offset + sz.width() ) {
+		offset = parag->at( selstart )->x;
+	    }
+	}
+    }
+private:
+    bool frm;
+    TQTextParagraph *parag;
+    TQTextCursor *cursor;
+    TQSize sz;
+    int focusSec;
+    TQValueList< TQNumberSection > sections;
+    TQString sep;
+    int offset;
+};
+
+/*!
+    Constructs an empty datetime editor with parent \a parent and
+    called \a name.
+*/
+ExtDateTimeEditor::ExtDateTimeEditor( ExtDateTimeEditBase * parent,
+				  const char * name )
+    : TQWidget( parent, name, WNoAutoErase )
+{
+    d = new ExtDateTimeEditorPrivate();
+    cw = parent;
+    init();
+}
+
+/*!
+    Destroys the object and frees any allocated resources.
+*/
+
+ExtDateTimeEditor::~ExtDateTimeEditor()
+{
+    delete d;
+}
+
+/*! \internal
+
+*/
+
+void ExtDateTimeEditor::init()
+{
+    setBackgroundMode( PaletteBase );
+    setFocusSection( -1 );
+    installEventFilter( this );
+    setFocusPolicy( TQ_WheelFocus );
+}
+
+
+/*! \reimp
+
+*/
+
+bool ExtDateTimeEditor::event( TQEvent *e )
+{
+    if ( e->type() == TQEvent::FocusIn || e->type() == TQEvent::FocusOut ) {
+ 	if ( e->type() == TQEvent::FocusOut )
+  	    tqApp->sendEvent( cw, e );
+	update( rect() );
+    } else if ( e->type() == TQEvent::AccelOverride ) {
+	TQKeyEvent* ke = (TQKeyEvent*) e;
+	switch ( ke->key() ) {
+	case Key_Delete:
+	case Key_Backspace:
+	case Key_Up:
+	case Key_Down:
+	case Key_Left:
+	case Key_Right:
+	    ke->accept();
+	default:
+	    break;
+	}
+    }
+    return TQWidget::event( e );
+}
+
+/*! \reimp
+
+*/
+
+void ExtDateTimeEditor::resizeEvent( TQResizeEvent *e )
+{
+    d->resize( e->size() );
+    TQWidget::resizeEvent( e );
+}
+
+
+/*! \reimp
+
+*/
+
+void ExtDateTimeEditor::paintEvent( TQPaintEvent * )
+{
+    TQString txt;
+    for ( uint i = 0; i < d->sectionCount(); ++i ) {
+	txt += cw->sectionFormattedText( i );
+	if ( i < d->sectionCount()-1 ) {
+	    if ( d->section( i+1 ).separator() )
+		txt += d->separator();
+	    else
+		txt += " ";
+	}
+    }
+
+    TQSharedDoubleBuffer buffer( this );
+    const TQBrush &bg =
+	tqcolorGroup().brush( isEnabled() ? TQColorGroup::Base : TQColorGroup::Background );
+    buffer.painter()->fillRect( 0, 0, width(), height(), bg );
+    d->paint( txt, hasFocus(), *buffer.painter(), tqcolorGroup(), rect(),
+	      tqstyle() );
+    buffer.end();
+}
+
+
+/*!
+    Returns the section index at point \a p.
+*/
+int ExtDateTimeEditor::sectionAt( const TQPoint &p )
+{
+    return d->section( p );
+}
+
+int ExtDateTimeEditor::mapSection( int sec )
+{
+    return d->mapSection( sec );
+}
+
+
+/*! \reimp
+
+*/
+
+void ExtDateTimeEditor::mousePressEvent( TQMouseEvent *e )
+{
+    TQPoint p( e->pos().x(), 0 );
+    int sec = sectionAt( p );
+    if ( sec != -1 ) {
+	cw->setFocusSection( sec );
+	tqrepaint( rect(), FALSE );
+    }
+}
+
+/*! \reimp
+
+*/
+bool ExtDateTimeEditor::eventFilter( TQObject *o, TQEvent *e )
+{
+    if ( TQT_BASE_OBJECT(o) == TQT_BASE_OBJECT(this) ) {
+	if ( e->type() == TQEvent::KeyPress ) {
+	    TQKeyEvent *ke = (TQKeyEvent*)e;
+	    switch ( ke->key() ) {
+	    case Key_Right:
+		if ( d->focusSection() < (int)d->sectionCount()-1 ) {
+		    if ( cw->setFocusSection( focusSection()+1 ) )
+			tqrepaint( rect(), FALSE );
+		}
+		return TRUE;
+	    case Key_Left:
+		if ( d->focusSection() > 0 ) {
+		    if ( cw->setFocusSection( focusSection()-1 ) )
+			tqrepaint( rect(), FALSE );
+		}
+		return TRUE;
+	    case Key_Up:
+		cw->stepUp();
+		return TRUE;
+	    case Key_Down:
+		cw->stepDown();
+		return TRUE;
+	    case Key_Backspace:
+		if ( ::tqqt_cast<ExtDateEdit*>(cw) )
+		    ((ExtDateEdit*)cw)->removeFirstNumber( d->focusSection() );
+		else if ( ::tqqt_cast<TQTimeEdit*>(cw) )
+		    ((TQTimeEdit*)cw)->removeFirstNumber( d->focusSection() );
+		return TRUE;
+	    case Key_Delete:
+		cw->removeLastNumber( d->focusSection() );
+		return TRUE;
+	    case Key_Tab:
+	    case Key_BackTab: {
+		if ( ke->state() == TQt::ControlButton )
+		    return FALSE;
+
+		TQWidget *w = this;
+		bool hadDateEdit = FALSE;
+		while ( w ) {
+		    if ( ::tqqt_cast<ExtDateTimeSpinWidget*>(w) && qstrcmp( w->name(), "qt_spin_widget" ) != 0 ||
+			 ::tqqt_cast<ExtDateTimeEdit*>(w) )
+			break;
+		    hadDateEdit = hadDateEdit || ::tqqt_cast<ExtDateEdit*>(w);
+		    w = w->parentWidget();
+		}
+
+		if ( w ) {
+		    if ( !::tqqt_cast<ExtDateTimeEdit*>(w) ) {
+			w = w->parentWidget();
+		    } else {
+			ExtDateTimeEdit *ed = (ExtDateTimeEdit*)w;
+			if ( hadDateEdit && ke->key() == Key_Tab ) {
+			    ed->timeEdit()->setFocus();
+			    return TRUE;
+			} else if ( !hadDateEdit && ke->key() == Key_BackTab ) {
+			    ed->dateEdit()->setFocus();
+			    return TRUE;
+			} else {
+			    while ( w && !::tqqt_cast<ExtDateTimeEdit*>(w) )
+				w = w->parentWidget();
+			}
+		    }
+
+		    tqApp->sendEvent( w, e );
+		    return TRUE;
+		}
+	    } break;
+	    default:
+		TQString txt = TQString(ke->text()).lower();
+		if ( !txt.isEmpty() && !separator().isEmpty() && txt[0] == separator()[0] ) {
+		    // do the same thing as KEY_RIGHT when the user presses the separator key
+		    if ( d->focusSection() < 2 ) {
+			if ( cw->setFocusSection( focusSection()+1 ) )
+			    tqrepaint( rect(), FALSE );
+		    }
+		    return TRUE;
+		} else if ( !txt.isEmpty() && ::tqqt_cast<TQTimeEdit*>(cw) && focusSection() == (int) d->sectionCount()-1 ) {
+		    // the first character of the AM/PM indicator toggles if the section has focus
+		    TQTimeEdit *te = (TQTimeEdit*)cw;
+		    TQTime time = te->time();
+		    if ( lAMPM && lAM && lPM && (te->display()&TQTimeEdit::AMPM) ) {
+			if ( txt[0] == (*lAM).lower()[0] && time.hour() >= 12 ) {
+			    time.setHMS( time.hour()-12, time.minute(), time.second(), time.msec() );
+			    te->setTime( time );
+			} else if ( txt[0] == (*lPM).lower()[0] && time.hour() < 12 ) {
+			    time.setHMS( time.hour()+12, time.minute(), time.second(), time.msec() );
+			    te->setTime( time );
+			}
+		    }
+		}
+
+		int num = txt[0].digitValue();
+		if ( num != -1 ) {
+		    cw->addNumber( d->focusSection(), num );
+		    return TRUE;
+		}
+	    }
+	}
+    }
+    return FALSE;
+}
+
+
+/*!
+    Appends the number section \a sec to the editor.
+*/
+
+void ExtDateTimeEditor::appendSection( const TQNumberSection& sec )
+{
+    d->appendSection( sec );
+}
+
+/*!
+    Removes all sections from the editor.
+*/
+
+void ExtDateTimeEditor::clearSections()
+{
+    d->clearSections();
+}
+
+/*!
+    Sets the selection of \a sec to start at \a selstart and end at \a
+    selend.
+*/
+
+void ExtDateTimeEditor::setSectionSelection( int sec, int selstart, int selend )
+{
+    d->setSectionSelection( sec, selstart, selend );
+}
+
+/*!
+    Sets the separator for all numbered sections to \a s. Note that
+    currently, only the first character of \a s is used.
+*/
+
+void ExtDateTimeEditor::setSeparator( const TQString& s )
+{
+    d->setSeparator( s );
+    update();
+}
+
+
+/*!
+    Returns the editor's separator.
+*/
+
+TQString ExtDateTimeEditor::separator() const
+{
+    return d->separator();
+}
+
+/*!
+    Returns the number of the section that has focus.
+*/
+
+int ExtDateTimeEditor::focusSection() const
+{
+    return d->focusSection();
+}
+
+
+/*!
+    Sets the focus to section \a sec. If \a sec does not exist,
+    nothing happens.
+*/
+
+bool ExtDateTimeEditor::setFocusSection( int sec )
+{
+    return d->setFocusSection( sec );
+}
+
+/*! \class ExtDateTimeEditBase ExtDatetimeedit.h
+    \brief The ExtDateTimeEditBase class provides an abstraction for date and edit editors.
+    \internal
+
+    Small abstract class that provides some functions that are common
+    for both ExtDateEdit and TQTimeEdit. Its used internally by
+    ExtDateTimeEditor.
+*/
+
+/*! \fn TQString ExtDateTimeEditBase::sectionFormattedText( int sec )
+    \internal
+
+  Pure virtual function which returns the formatted text of section \a
+  sec.
+
+*/
+
+/*! \fn void ExtDateTimeEditBase::stepUp()
+    \internal
+
+  Pure virtual slot which is called whenever the user increases the
+  number in a section by pressing the widget's arrow buttons or the
+  keyboard's arrow keys.
+*/
+
+/*! \fn void ExtDateTimeEditBase::stepDown()
+    \internal
+
+  Pure virtual slot which is called whenever the user decreases the
+  number in a section by pressing the widget's arrow buttons or the
+  keyboard's arrow keys.
+
+*/
+
+/*! \fn void ExtDateTimeEditBase::addNumber( int sec, int num )
+    \internal
+
+  Pure virtual function which is called whenever the user types a number.
+  \a sec indicates the section where the number should be added. \a
+  num is the number that was pressed.
+*/
+
+/*! \fn void ExtDateTimeEditBase::removeLastNumber( int sec )
+    \internal
+
+  Pure virtual function which is called whenever the user tries to
+  remove the last number from \a sec by pressing the delete key.
+*/
+
+////////////////
+
+class ExtDateEditPrivate
+{
+public:
+    int y;
+    int m;
+    int d;
+    // remebers the last entry for the day.
+    // if the day is 31 and you cycle through the months,
+    // the day will be 31 again if you reach a month with 31 days
+    // otherwise it will be the highest day in the month
+    int dayCache;
+    int yearSection;
+    int monthSection;
+    int daySection;
+    ExtDateEdit::Order ord;
+    bool overwrite;
+    bool adv;
+    int timerId;
+    bool typing;
+    ExtDate min;
+    ExtDate max;
+    bool changed;
+    ExtDateTimeEditor *ed;
+    TQSpinWidget *controls;
+};
+
+
+/*!
+    \class ExtDateEdit ExtDatetimeedit.h
+    \brief The ExtDateEdit class provides a date editor.
+
+    \ingroup advanced
+    \ingroup time
+
+    ExtDateEdit allows the user to edit dates by using the keyboard or
+    the arrow keys to increase/decrease date values. The arrow keys
+    can be used to move from section to section within the ExtDateEdit
+    box. Dates appear in accordance with the local date/time settings
+    or in year, month, day order if the system doesn't provide this
+    information. It is recommended that the ExtDateEdit be initialised
+    with a date, e.g.
+
+    \code
+    ExtDateEdit *dateEdit = new ExtDateEdit( ExtDate::tqcurrentDate(), this );
+    dateEdit->setRange( ExtDate::tqcurrentDate().addDays( -365 ),
+			ExtDate::tqcurrentDate().addDays(  365 ) );
+    dateEdit->setOrder( ExtDateEdit::MDY );
+    dateEdit->setAutoAdvance( TRUE );
+    \endcode
+
+    Here we've created a new ExtDateEdit object initialised with today's
+    date and restricted the valid date range to today plus or minus
+    365 days. We've set the order to month, day, year. If the auto
+    advance property is TRUE (as we've set it here) when the user
+    completes a section of the date, e.g. enters two digits for the
+    month, they are automatically taken to the next section.
+
+    The maximum and minimum values for a date value in the date editor
+    default to the maximum and minimum values for a ExtDate. You can
+    change this by calling setMinValue(), setMaxValue() or setRange().
+
+    Terminology: A ExtDateEdit widget comprises three 'sections', one
+    each for the year, month and day. You can change the separator
+    character using ExtDateTimeEditor::setSeparator(), by default the
+    separator will be taken from the systems settings. If that is
+    not possible, it defaults to "-".
+
+    \image html datetimewidgets.png "Date Time Widgets"
+
+    \sa ExtDate TQTimeEdit ExtDateTimeEdit
+*/
+
+/*!
+    \enum ExtDateEdit::Order
+
+    This enum defines the order in which the sections that comprise a
+    date appear.
+
+*/
+
+
+/*!
+    \enum TQTimeEdit::Display
+
+    This enum defines the sections that comprise a time
+
+    \value Hours The hours section
+    \value Minutes The minutes section
+    \value Seconds The seconds section
+    \value AMPM The AM/PM section
+
+    The values can be or'ed together to show any combination.
+*/
+
+/*!
+    Constructs an empty date editor which is a child of \a parent and
+    called name \a name.
+*/
+
+ExtDateEdit::ExtDateEdit( TQWidget * parent, const char * name )
+    : ExtDateTimeEditBase( parent, name )
+{
+    init();
+    updateButtons();
+}
+
+/*!
+    \overload
+
+    Constructs a date editor with the initial value \a date, parent \a
+    parent and called \a name.
+
+    The date editor is initialized with \a date.
+*/
+
+ExtDateEdit::ExtDateEdit( const ExtDate& date, TQWidget * parent, const char * name )
+    : ExtDateTimeEditBase( parent, name )
+{
+    init();
+    setDate( date );
+}
+
+/*! \internal
+*/
+void ExtDateEdit::init()
+{
+  d = new ExtDateEditPrivate();
+  d->controls = new ExtDateTimeSpinWidget( this, 
+      qstrcmp( name(), "qt_datetime_dateedit" ) == 0 ? 
+      "qt_spin_widget" : "date edit controls" );
+  d->ed = new ExtDateTimeEditor( this, "date editor" );
+  d->controls->setEditWidget( d->ed );
+  setFocusProxy( d->ed );
+  connect( d->controls, TQT_SIGNAL( stepUpPressed() ), TQT_SLOT( stepUp() ) );
+  connect( d->controls, TQT_SIGNAL( stepDownPressed() ), TQT_SLOT( stepDown() ) );
+  connect( this, TQT_SIGNAL( valueChanged(const ExtDate&) ),
+      TQT_SLOT( updateButtons() ) );
+  d->ed->appendSection( TQNumberSection( 0,4 ) );
+  d->ed->appendSection( TQNumberSection( 5,7 ) );
+  d->ed->appendSection( TQNumberSection( 8,10 ) );
+
+  d->yearSection = -1;
+  d->monthSection = -1;
+  d->daySection = -1;
+
+  d->y = 0;
+  d->m = 0;
+  d->d = 0;
+  d->dayCache = 0;
+  setOrder( localOrder() );
+  setFocusSection( 0 );
+  d->overwrite = TRUE;
+  d->adv = FALSE;
+  d->timerId = 0;
+  d->typing = FALSE;
+  d->min = ExtDate( -50000, 1, 1 );
+  d->max = ExtDate( 50000, 12, 31 );
+  d->changed = FALSE;
+
+  tqsetSizePolicy( TQSizePolicy::Minimum, TQSizePolicy::Fixed );
+
+  refcount++;
+}
+
+/*!
+    Destroys the object and frees any allocated resources.
+*/
+
+ExtDateEdit::~ExtDateEdit()
+{
+  delete d;
+  if ( !--refcount )
+    cleanup();
+}
+
+/*!
+    \property ExtDateEdit::minValue
+
+    \brief the editor's minimum value
+
+    Setting the minimum date value is equivalent to calling
+    ExtDateEdit::setRange( \e d, maxValue() ), where \e d is the minimum
+    date. The default minimum date is 1752-09-14.
+
+    \sa maxValue setRange()
+*/
+
+ExtDate ExtDateEdit::minValue() const
+{
+  return d->min;
+}
+
+/*!
+    \property ExtDateEdit::maxValue
+
+    \brief the editor's maximum value
+
+    Setting the maximum date value for the editor is equivalent to
+    calling ExtDateEdit::setRange( minValue(), \e d ), where \e d is the
+    maximum date. The default maximum date is 8000-12-31.
+
+    \sa minValue setRange()
+*/
+
+ExtDate ExtDateEdit::maxValue() const
+{
+  return d->max;
+}
+
+
+/*!
+    Sets the valid input range for the editor to be from \a min to \a
+    max inclusive. If \a min is invalid no minimum date will be set.
+    Similarly, if \a max is invalid no maximum date will be set.
+*/
+
+void ExtDateEdit::setRange( const ExtDate& min, const ExtDate& max )
+{
+  if ( min.isValid() )
+    d->min = min;
+  if ( max.isValid() )
+    d->max = max;
+}
+
+/*!
+    Sets the separator to \a s. Note that currently only the first
+    character of \a s is used.
+*/
+
+void ExtDateEdit::setSeparator( const TQString& s )
+{
+  d->ed->setSeparator( s );
+}
+
+/*!
+    Returns the editor's separator.
+*/
+
+TQString ExtDateEdit::separator() const
+{
+  return d->ed->separator();
+}
+
+
+/*!
+    Enables/disables the push buttons according to the min/max date
+    for this widget.
+*/
+
+void ExtDateEdit::updateButtons()
+{
+  if ( !isEnabled() )
+    return;
+
+  fix();
+  
+  bool upEnabled = date() < maxValue();
+  bool downEnabled = date() > minValue();
+
+  d->controls->setUpEnabled( upEnabled );
+  d->controls->setDownEnabled( downEnabled );
+}
+
+/*! \reimp
+ */
+void ExtDateEdit::resizeEvent( TQResizeEvent * )
+{
+  d->controls->resize( width(), height() );
+}
+
+/*! \reimp
+
+*/
+TQSize ExtDateEdit::tqsizeHint() const
+{
+  constPolish();
+  TQFontMetrics fm( font() );
+  int fw = tqstyle().tqpixelMetric( TQStyle::PM_DefaultFrameWidth, this );
+  int h = TQMAX( fm.lineSpacing(), 14 ) + 2;
+  int w = 2 + fm.width( '9' ) * 8 + fm.width( d->ed->separator() ) * 2 
+            + d->controls->upRect().width() + fw * 4;
+
+  return TQSize( w, TQMAX(h + fw * 2,20) ).expandedTo( TQApplication::globalStrut() );
+}
+
+/*! \reimp
+
+*/
+TQSize ExtDateEdit::tqminimumSizeHint() const
+{
+  return tqsizeHint();
+}
+
+
+/*!
+    Returns the formatted number for section \a sec. This will
+    correspond to either the year, month or day section, depending on
+    the current display order.
+
+    \sa setOrder()
+*/
+
+TQString ExtDateEdit::sectionFormattedText( int sec )
+{
+  TQString txt;
+  txt = sectionText( sec );
+  if ( d->typing && sec == d->ed->focusSection() )
+    d->ed->setSectionSelection( sec, sectionOffsetEnd( sec ) - txt.length(),
+        sectionOffsetEnd( sec ) );
+  else
+    d->ed->setSectionSelection( sec, sectionOffsetEnd( sec ) - sectionLength( sec ),
+        sectionOffsetEnd( sec ) );
+  
+  txt = txt.rightJustify( sectionLength( sec ), EXTDATETIMEEDIT_HIDDEN_CHAR );
+  return txt;
+}
+
+
+/*!
+    Returns the desired length (number of digits) of section \a sec.
+    This will correspond to either the year, month or day section,
+    depending on the current display order.
+
+    \sa setOrder()
+*/
+
+int ExtDateEdit::sectionLength( int sec ) const
+{
+  int val = 0;
+  if ( sec == d->yearSection ) 
+    val = 4;
+  else if ( sec == d->monthSection ) 
+    val = 2;
+  else if ( sec == d->daySection ) 
+    val = 2;
+  
+  return val;
+}
+
+/*!
+    Returns the text of section \a sec. This will correspond to either
+    the year, month or day section, depending on the current display
+    order.
+
+    \sa setOrder()
+*/
+
+TQString ExtDateEdit::sectionText( int sec ) const
+{
+  int val = 0;
+  if ( sec == d->yearSection ) 
+    val = d->y;
+  else if ( sec == d->monthSection ) 
+    val = d->m;
+  else if ( sec == d->daySection ) 
+    val = d->d;
+    
+  return TQString::number( val );
+}
+
+/*! \internal
+
+  Returns the end of the section offset \a sec.
+
+*/
+
+int ExtDateEdit::sectionOffsetEnd( int sec ) const
+{
+  if ( sec == d->yearSection ) {
+    switch( d->ord ) {
+      case DMY:
+      case MDY:
+        return sectionOffsetEnd( sec-1) + separator().length() + sectionLength( sec );
+      case YMD:
+      case YDM:
+        return sectionLength( sec );
+    }
+  } else if ( sec == d->monthSection ) {
+    switch( d->ord ) {
+      case DMY:
+      case YDM:
+      case YMD:
+        return sectionOffsetEnd( sec-1) + separator().length() + sectionLength( sec );
+      case MDY:
+        return sectionLength( sec );
+    }
+  } else if ( sec == d->daySection ) {
+    switch( d->ord ) {
+      case DMY:
+        return sectionLength( sec );
+      case YMD:
+      case MDY:
+      case YDM:
+        return sectionOffsetEnd( sec-1 ) + separator().length() + sectionLength( sec );
+    }
+  }
+  return 0;
+}
+
+
+/*!
+    \property ExtDateEdit::order
+    \brief the order in which the year, month and day appear
+
+    The default order is locale dependent.
+
+    \sa Order
+*/
+
+void ExtDateEdit::setOrder( ExtDateEdit::Order order )
+{
+  d->ord = order;
+  switch( d->ord ) {
+    case DMY:
+      d->yearSection = 2;
+      d->monthSection = 1;
+      d->daySection = 0;
+      break;
+    case MDY:
+      d->yearSection = 2;
+      d->monthSection = 0;
+      d->daySection = 1;
+      break;
+    case YMD:
+      d->yearSection = 0;
+      d->monthSection = 1;
+      d->daySection = 2;
+      break;
+    case YDM:
+      d->yearSection = 0;
+      d->monthSection = 2;
+      d->daySection = 1;
+      break;
+  }
+  
+  if ( isVisible() )
+    d->ed->tqrepaint( d->ed->rect(), FALSE );
+}
+
+
+ExtDateEdit::Order ExtDateEdit::order() const
+{
+  return d->ord;
+}
+
+
+/*! \reimp
+
+*/
+void ExtDateEdit::stepUp()
+{
+  int sec = d->ed->focusSection();
+  bool accepted = FALSE;
+  if ( sec == d->yearSection ) {
+    if ( !outOfRange( d->y+1, d->m, d->d ) ) {
+      accepted = TRUE;
+      setYear( d->y+1 );
+    }
+  } else if ( sec == d->monthSection ) {
+  	if ( !outOfRange( d->y, d->m+1, d->d ) ) {
+      accepted = TRUE;
+      setMonth( d->m+1 );
+  	}
+  } else if ( sec == d->daySection ) {
+    if ( !outOfRange( d->y, d->m, d->d+1 ) ) {
+      accepted = TRUE;
+      setDay( d->d+1 );
+    }
+  }
+  if ( accepted ) {
+    d->changed = TRUE;
+    emit valueChanged( date() );
+  }
+  
+  d->ed->tqrepaint( d->ed->rect(), FALSE );
+}
+
+
+
+/*! \reimp
+
+*/
+
+void ExtDateEdit::stepDown()
+{
+  int sec = d->ed->focusSection();
+  bool accepted = FALSE;
+  if ( sec == d->yearSection ) {
+    if ( !outOfRange( d->y-1, d->m, d->d ) ) {
+      accepted = TRUE;
+      setYear( d->y-1 );
+    }
+  } else if ( sec == d->monthSection ) {
+    if ( !outOfRange( d->y, d->m-1, d->d ) ) {
+      accepted = TRUE;
+      setMonth( d->m-1 );
+    }
+  } else if ( sec == d->daySection ) {
+    if ( !outOfRange( d->y, d->m, d->d-1 ) ) {
+      accepted = TRUE;
+      setDay( d->d-1 );
+    }
+  }
+  if ( accepted ) {
+    d->changed = TRUE;
+    emit valueChanged( date() );
+  }
+  
+  d->ed->tqrepaint( d->ed->rect(), FALSE );
+}
+
+/*!
+    Sets the year to \a year, which must be a valid year. The range
+    currently supported is from 1752 to 8000.
+
+    \sa ExtDate
+*/
+
+void ExtDateEdit::setYear( int year )
+{
+  if ( !outOfRange( year, d->m, d->d ) ) {
+    d->y = year;
+    setMonth( d->m );
+  }
+}
+
+
+/*!
+    Sets the month to \a month, which must be a valid month, i.e.
+    between 1 and 12.
+*/
+
+void ExtDateEdit::setMonth( int month )
+{
+  if ( month < 1 )
+    month = 1;
+  if ( month > 12 )
+    month = 12;
+  if ( !outOfRange( d->y, month, d->d ) ) {
+    d->m = month;
+    setDay( d->d );
+  }
+}
+
+
+/*!
+    Sets the day to \a day, which must be a valid day. The function
+    will ensure that the \a day set is valid for the month and year.
+*/
+
+void ExtDateEdit::setDay( int day )
+{
+  ExtDate test = ExtDate( d->y, d->m, 1 );
+  
+  if ( day < 1 )
+    day = 1;
+  if ( day > test.daysInMonth() )
+    day = test.daysInMonth();
+  
+  d->dayCache = d->d;
+  d->d = day;
+}
+
+
+/*!
+    \property ExtDateEdit::date
+    \brief the editor's date value.
+
+    If the date property is not valid, the editor displays all zeroes
+    and ExtDateEdit::date() will return an invalid date. It is strongly
+    recommended that the editor is given a default date value (e.g.
+    tqcurrentDate()). That way, attempts to set the date property to an
+    invalid date will fail.
+
+    When changing the date property, if the date is less than
+    minValue(), or is greater than maxValue(), nothing happens.
+*/
+
+void ExtDateEdit::setDate( const ExtDate& date )
+{
+  if ( !date.isValid() ) {
+    d->y = 0;
+    d->m = 0;
+    d->d = 0;
+    d->dayCache = 0;
+  } else {
+    if ( date > maxValue() || date < minValue() )
+      return;
+    d->y = date.year();
+    d->m = date.month();
+    d->d = date.day();
+    d->dayCache = d->d;
+    emit valueChanged( date );
+  }
+  d->changed = FALSE;
+  d->ed->tqrepaint( d->ed->rect(), FALSE );
+}
+
+ExtDate ExtDateEdit::date() const
+{
+    if ( ExtDate::isValid( d->y, d->m, d->d ) )
+	return ExtDate( d->y, d->m, d->d );
+    return ExtDate();
+}
+
+/*!  \internal
+
+  Returns TRUE if \a y, \a m, \a d is out of range, otherwise returns
+  FALSE.
+
+  \sa setRange()
+
+*/
+
+bool ExtDateEdit::outOfRange( int y, int m, int d ) const
+{
+  if ( ExtDate::isValid( y, m, d ) ) {
+    ExtDate tqcurrentDate( y, m, d );
+    if ( tqcurrentDate > maxValue() || tqcurrentDate < minValue() ) {
+	    //## outOfRange should set overwrite?
+	    return TRUE;
+    }
+    return FALSE;
+  }
+  return FALSE; /* assume ok */
+}
+
+/*!  \reimp
+
+*/
+
+void ExtDateEdit::addNumber( int sec, int num )
+{
+    if ( sec == -1 )
+	return;
+    killTimer( d->timerId );
+    bool overwrite = FALSE;
+    bool accepted = FALSE;
+    d->typing = TRUE;
+    TQString txt;
+    if ( sec == d->yearSection ) {
+      if ( d->overwrite ) {
+	d->y = num;
+	d->overwrite = FALSE;
+	accepted = TRUE;
+      } else {
+	txt = TQString::number( 10*d->y + num );
+	if ( txt.length() > 5 ) txt = txt.mid(1);
+	d->y = txt.toInt();
+	accepted = TRUE;
+      }
+/*
+	txt = TQString::number( d->y );
+	if ( d->overwrite || txt.length() == 4 ) {
+	    accepted = TRUE;
+	    d->y = num;
+	} else {
+	    txt += TQString::number( num );
+	    if ( txt.length() == 4  ) {
+		int val = txt.toInt();
+		if ( val < 1792 )
+		    d->y = 1792;
+		else if ( val > 8000 )
+		    d->y = 8000;
+		else if ( outOfRange( val, d->m, d->d ) )
+		    txt = TQString::number( d->y );
+		else {
+		    accepted = TRUE;
+		    d->y = val;
+		}
+	    } else {
+		accepted = TRUE;
+		d->y = txt.toInt();
+	    }
+	    if ( d->adv && txt.length() == 4 ) {
+		d->ed->setFocusSection( d->ed->focusSection()+1 );
+		overwrite = TRUE;
+	    }
+	}
+*/
+    } else if ( sec == d->monthSection ) {
+	txt = TQString::number( d->m );
+	if ( d->overwrite || txt.length() == 2 ) {
+	    accepted = TRUE;
+	    d->m = num;
+	} else {
+	    txt += TQString::number( num );
+	    int temp = txt.toInt();
+	    if ( temp > 12 )
+		temp = num;
+	    if ( outOfRange( d->y, temp, d->d ) )
+		txt = TQString::number( d->m );
+	    else {
+		accepted = TRUE;
+		d->m = temp;
+	    }
+	    if ( d->adv && txt.length() == 2 ) {
+		d->ed->setFocusSection( d->ed->focusSection()+1 );
+		overwrite = TRUE;
+	    }
+	}
+    } else if ( sec == d->daySection ) {
+	txt = TQString::number( d->d );
+	if ( d->overwrite || txt.length() == 2 ) {
+	    accepted = TRUE;
+	    d->d = num;
+	    d->dayCache = d->d;
+	} else {
+	    txt += TQString::number( num );
+	    int temp = txt.toInt();
+	    if ( temp > 31 )
+		temp = num;
+	    if ( outOfRange( d->y, d->m, temp ) )
+		txt = TQString::number( d->d );
+	    else {
+		accepted = TRUE;
+		d->d = temp;
+		d->dayCache = d->d;
+	    }
+	    if ( d->adv && txt.length() == 2 ) {
+		d->ed->setFocusSection( d->ed->focusSection()+1 );
+		overwrite = TRUE;
+	    }
+	}
+    }
+    if ( accepted ) {
+	d->changed = TRUE;
+	emit valueChanged( date() );
+    }
+    d->overwrite = overwrite;
+    d->timerId = startTimer( tqApp->doubleClickInterval()*4 );
+    d->ed->tqrepaint( d->ed->rect(), FALSE );
+}
+
+
+/*! \reimp
+
+*/
+
+bool ExtDateEdit::setFocusSection( int s )
+{
+  if ( s != d->ed->focusSection() ) {
+    killTimer( d->timerId );
+    d->overwrite = TRUE;
+    d->typing = FALSE;
+    fix(); // will emit valueChanged if necessary
+  }
+  return d->ed->setFocusSection( s );
+}
+
+
+/*!
+    Attempts to fix any invalid date entries.
+
+    The rules applied are as follows:
+
+    - if the day is larger than the number of days in the month, 
+    - it is reset to that number
+    - If the year has four digits it is left unchanged.
+    - If the year has two digits, the year will be changed to four
+      digits in the range current year - 70 to current year + 29.
+    - If the year has three digits in the range 100..999, the
+      current millennium, i.e. 2000, will be added giving a year
+      in the range 2100..2999.
+
+*/
+
+void ExtDateEdit::fix()
+{
+  bool changed = FALSE;
+  
+  ExtDate test = ExtDate( d->y, d->m, 1 );
+  if ( d->d > test.daysInMonth() ) {
+    
+    d->d = test.daysInMonth();
+    changed = TRUE;
+  }
+  
+  int currentYear = ExtDate::tqcurrentDate().year();
+  int year = d->y;
+/* No longer valid for extended dates
+  if ( year < 100 ) {
+    int currentCentury = currentYear / 100;
+    year += currentCentury * 100;
+    if ( currentYear > year ) {
+        if ( currentYear > year + 70 )
+      year += 100;
+    } else {
+        if ( year >= currentYear + 30 )
+      year -= 100;
+    }
+    changed = TRUE;
+      } else if ( year < 1000 ) {
+    int currentMillennium = currentYear / 10;
+    year += currentMillennium * 10;
+    changed = TRUE;
+  }
+*/
+  if ( changed && outOfRange( year, d->m, d->d ) ) {
+  	if ( minValue().isValid() && date() < minValue() ) {
+	    d->d =  minValue().day();
+	    d->dayCache = d->d;
+	    d->m = minValue().month();
+	    d->y = minValue().year();
+    }
+    if ( date() > maxValue() ) {
+	    d->d =  maxValue().day();
+	    d->dayCache = d->d;
+	    d->m = maxValue().month();
+	    d->y = maxValue().year();
+    }
+  } else if ( changed )
+    setYear( year );
+    
+  if ( changed ) {
+//    emit valueChanged( date() );
+//    d->changed = FALSE;
+  }
+}
+
+
+/*! \reimp
+
+*/
+
+bool ExtDateEdit::event( TQEvent *e )
+{
+  if( e->type() == TQEvent::FocusOut ) {
+    d->typing = FALSE;
+    d->overwrite = TRUE;
+    // the following can't be done in fix() because fix() called
+    // from all over the place and it will break the old behaviour
+    if ( !ExtDate::isValid( d->y, d->m, d->d ) ) {
+      d->dayCache = d->d;
+      int i = d->d;
+      for ( ; i > 0; i-- ) {
+        d->d = i;
+        if ( ExtDate::isValid( d->y, d->m, d->d ) )
+          break;
+      }
+      d->changed = TRUE;
+    }
+    if ( d->changed ) {
+      fix();
+      emit valueChanged( date() );
+      d->changed = FALSE;
+    }
+  } else if ( e->type() == TQEvent::LocaleChange ) {
+    readLocaleSettings();
+    d->ed->setSeparator( localDateSep() );
+    setOrder( localOrder() );
+  }
+
+  bool result = ExtDateTimeEditBase::event( e ); 
+  
+  return result;
+}
+
+/*!
+  \internal
+
+  Function which is called whenever the user tries to
+  remove the first number from \a sec by pressing the backspace key.
+*/
+
+void ExtDateEdit::removeFirstNumber( int sec )
+{
+    if ( sec == -1 )
+	return;
+    TQString txt;
+    if ( sec == d->yearSection ) {
+	txt = TQString::number( d->y );
+	txt = txt.mid( 1, txt.length() ) + "0";
+	d->y = txt.toInt();
+    } else if ( sec == d->monthSection ) {
+	txt = TQString::number( d->m );
+	txt = txt.mid( 1, txt.length() ) + "0";
+	d->m = txt.toInt();
+    } else if ( sec == d->daySection ) {
+	txt = TQString::number( d->d );
+	txt = txt.mid( 1, txt.length() ) + "0";
+	d->d = txt.toInt();
+	d->dayCache = d->d;
+    }
+    d->ed->tqrepaint( d->ed->rect(), FALSE );
+}
+
+/*! \reimp
+
+*/
+
+void ExtDateEdit::removeLastNumber( int sec )
+{
+    if ( sec == -1 )
+	return;
+    TQString txt;
+    if ( sec == d->yearSection ) {
+	txt = TQString::number( d->y );
+	txt = txt.mid( 0, txt.length()-1 );
+	d->y = txt.toInt();
+    } else if ( sec == d->monthSection ) {
+	txt = TQString::number( d->m );
+	txt = txt.mid( 0, txt.length()-1 );
+	d->m = txt.toInt();
+    } else if ( sec == d->daySection ) {
+	txt = TQString::number( d->d );
+	txt = txt.mid( 0, txt.length()-1 );
+	d->d = txt.toInt();
+	d->dayCache = d->d;
+    }
+    d->ed->tqrepaint( d->ed->rect(), FALSE );
+}
+
+/*!
+    \property ExtDateEdit::autoAdvance
+    \brief whether the editor automatically advances to the next
+    section
+
+    If autoAdvance is TRUE, the editor will automatically advance
+    focus to the next date section if a user has completed a section.
+    The default is FALSE.
+*/
+
+void ExtDateEdit::setAutoAdvance( bool advance )
+{
+    d->adv = advance;
+}
+
+
+bool ExtDateEdit::autoAdvance() const
+{
+    return d->adv;
+}
+
+/*! \reimp
+*/
+
+void ExtDateEdit::timerEvent( TQTimerEvent * )
+{
+    d->overwrite = TRUE;
+}
+
+/*!
+    \fn void ExtDateEdit::valueChanged( const ExtDate& date )
+
+    This signal is emitted whenever the editor's value changes. The \a
+    date parameter is the new value.
+*/
+
+///////////
+
+class TQTimeEditPrivate
+{
+public:
+    int h;
+    int m;
+    int s;
+    uint display;
+    bool adv;
+    bool overwrite;
+    int timerId;
+    bool typing;
+    TQTime min;
+    TQTime max;
+    bool changed;
+    ExtDateTimeEditor *ed;
+    TQSpinWidget *controls;
+};
+
+/*!
+    \class TQTimeEdit ExtDatetimeedit.h
+    \brief The TQTimeEdit class provides a time editor.
+
+    \ingroup advanced
+    \ingroup time
+    \mainclass
+
+    TQTimeEdit allows the user to edit times by using the keyboard or
+    the arrow keys to increase/decrease time values. The arrow keys
+    can be used to move from section to section within the TQTimeEdit
+    box. The user can automatically be moved to the next section once
+    they complete a section using setAutoAdvance(). Times appear in
+    hour, minute, second order. It is recommended that the TQTimeEdit
+    is initialised with a time, e.g.
+    \code
+    TQTime timeNow = TQTime::currentTime();
+    TQTimeEdit *timeEdit = new TQTimeEdit( timeNow, this );
+    timeEdit->setRange( timeNow, timeNow.addSecs( 60 * 60 ) );
+    \endcode
+    Here we've created a TQTimeEdit widget set to the current time.
+    We've also set the minimum value to the current time and the
+    maximum time to one hour from now.
+
+    The maximum and minimum values for a time value in the time editor
+    default to the maximum and minimum values for a TQTime. You can
+    change this by calling setMinValue(), setMaxValue() or setRange().
+
+    Terminology: A TQTimeWidget consists of three sections, one each
+    for the hour, minute and second. You can change the separator
+    character using setSeparator(), by default the separator is read
+    from the system's settings.
+
+    \img datetimewidgets.png Date Time Widgets
+
+    \sa TQTime ExtDateEdit ExtDateTimeEdit
+*/
+
+
+// /*!
+//     Constructs an empty time edit with parent \a parent and called \a
+//     name.
+// */
+//
+// TQTimeEdit::TQTimeEdit( TQWidget * parent, const char * name )
+//     : ExtDateTimeEditBase( parent, name )
+// {
+//     init();
+// }
+//
+// /*!
+//     \overload
+//
+//     Constructs a time edit with the initial time value, \a time,
+//     parent \a parent and called \a name.
+// */
+//
+// TQTimeEdit::TQTimeEdit( const TQTime& time, TQWidget * parent, const char * name )
+//     : ExtDateTimeEditBase( parent, name )
+// {
+//     init();
+//     setTime( time );
+// }
+//
+// /*! \internal
+//  */
+//
+// void TQTimeEdit::init()
+// {
+//     d = new TQTimeEditPrivate();
+//     d->ed = new ExtDateTimeEditor( this, "time edit base" );
+//     d->controls = new ExtDateTimeSpinWidget( this, qstrcmp( name(), "qt_datetime_timeedit" ) == 0 ? "qt_spin_widget" : "time edit controls" );
+//     d->controls->setEditWidget( d->ed );
+//     setFocusProxy( d->ed );
+//     connect( d->controls, TQT_SIGNAL( stepUpPressed() ), TQT_SLOT( stepUp() ) );
+//     connect( d->controls, TQT_SIGNAL( stepDownPressed() ), TQT_SLOT( stepDown() ) );
+//
+//     d->ed->appendSection( TQNumberSection( 0,0, TRUE, 0 ) );
+//     d->ed->appendSection( TQNumberSection( 0,0, TRUE, 1 ) );
+//     d->ed->appendSection( TQNumberSection( 0,0, TRUE, 2 ) );
+//     d->ed->setSeparator( localTimeSep() );
+//
+//     d->h = 0;
+//     d->m = 0;
+//     d->s = 0;
+//     d->display = Hours | Minutes | Seconds;
+//     if ( lAMPM ) {
+// 	d->display |= AMPM;
+// 	d->ed->appendSection( TQNumberSection( 0,0, FALSE, 3 ) );
+//     }
+//     d->adv = FALSE;
+//     d->overwrite = TRUE;
+//     d->timerId = 0;
+//     d->typing = FALSE;
+//     d->min = TQTime( 0, 0, 0 );
+//     d->max = TQTime( 23, 59, 59 );
+//     d->changed = FALSE;
+//
+//     tqsetSizePolicy( TQSizePolicy::Minimum, TQSizePolicy::Fixed );
+//
+//     refcount++;
+// }
+//
+// /*!
+//     Destroys the object and frees any allocated resources.
+// */
+//
+// TQTimeEdit::~TQTimeEdit()
+// {
+//     delete d;
+//     if ( !--refcount )
+// 	cleanup();
+// }
+//
+// /*!
+//     \property TQTimeEdit::minValue
+//     \brief the minimum time value
+//
+//     Setting the minimum time value is equivalent to calling
+//     TQTimeEdit::setRange( \e t, maxValue() ), where \e t is the minimum
+//     time. The default minimum time is 00:00:00.
+//
+//     \sa maxValue setRange()
+// */
+//
+// TQTime TQTimeEdit::minValue() const
+// {
+//     return d->min;
+// }
+//
+// /*!
+//     \property TQTimeEdit::maxValue
+//     \brief the maximum time value
+//
+//     Setting the maximum time value is equivalent to calling
+//     TQTimeEdit::setRange( minValue(), \e t ), where \e t is the maximum
+//     time. The default maximum time is 23:59:59.
+//
+//     \sa minValue setRange()
+// */
+//
+// TQTime TQTimeEdit::maxValue() const
+// {
+//     return d->max;
+// }
+//
+//
+// /*!
+//     Sets the valid input range for the editor to be from \a min to \a
+//     max inclusive. If \a min is invalid no minimum time is set.
+//     Similarly, if \a max is invalid no maximum time is set.
+// */
+//
+// void TQTimeEdit::setRange( const TQTime& min, const TQTime& max )
+// {
+//     if ( min.isValid() )
+// 	d->min = min;
+//     if ( max.isValid() )
+// 	d->max = max;
+// }
+//
+// /*!
+//   \property TQTimeEdit::display
+//   \brief the sections that are displayed in the time edit
+//
+//   The value can be any combination of the values in the Display enum.
+//   By default, the widget displays hours, minutes and seconds.
+// */
+// void TQTimeEdit::setDisplay( uint display )
+// {
+//     if ( d->display == display )
+// 	return;
+//
+//     d->ed->clearSections();
+//     d->display = display;
+//     if ( d->display & Hours )
+// 	d->ed->appendSection( TQNumberSection( 0,0, TRUE, 0 ) );
+//     if ( d->display & Minutes )
+// 	d->ed->appendSection( TQNumberSection( 0,0, TRUE, 1 ) );
+//     if ( d->display & Seconds )
+// 	d->ed->appendSection( TQNumberSection( 0,0, TRUE, 2 ) );
+//     if ( d->display & AMPM )
+// 	d->ed->appendSection( TQNumberSection( 0,0, FALSE, 3 ) );
+//
+//     d->ed->setFocusSection( 0 );
+//     d->ed->update();
+// }
+//
+// uint TQTimeEdit::display() const
+// {
+//     return d->display;
+// }
+//
+// /*!
+//     \property TQTimeEdit::time
+//     \brief the editor's time value.
+//
+//     When changing the time property, if the time is less than
+//     minValue(), or is greater than maxValue(), nothing happens.
+// */
+//
+// void TQTimeEdit::setTime( const TQTime& time )
+// {
+//     if ( !time.isValid() ) {
+// 	d->h = 0;
+// 	d->m = 0;
+// 	d->s = 0;
+//     } else {
+// 	if ( time > maxValue() || time < minValue() )
+// 	    return;
+// 	d->h = time.hour();
+// 	d->m = time.minute();
+// 	d->s = time.second();
+// 	emit valueChanged( time );
+//     }
+//     d->changed = FALSE;
+//     d->ed->tqrepaint( d->ed->rect(), FALSE );
+// }
+//
+// TQTime TQTimeEdit::time() const
+// {
+//     if ( TQTime::isValid( d->h, d->m, d->s ) )
+// 	return TQTime( d->h, d->m, d->s );
+//     return TQTime();
+// }
+//
+// /*!
+//     \property TQTimeEdit::autoAdvance
+//     \brief whether the editor automatically advances to the next
+//     section
+//
+//     If autoAdvance is TRUE, the editor will automatically advance
+//     focus to the next time section if a user has completed a section.
+//     The default is FALSE.
+// */
+//
+// void TQTimeEdit::setAutoAdvance( bool advance )
+// {
+//     d->adv = advance;
+// }
+//
+// bool TQTimeEdit::autoAdvance() const
+// {
+//     return d->adv;
+// }
+//
+// /*!
+//     Sets the separator to \a s. Note that currently only the first
+//     character of \a s is used.
+// */
+//
+// void TQTimeEdit::setSeparator( const TQString& s )
+// {
+//     d->ed->setSeparator( s );
+// }
+//
+// /*!
+//     Returns the editor's separator.
+// */
+//
+// TQString TQTimeEdit::separator() const
+// {
+//     return d->ed->separator();
+// }
+//
+//
+// /*!
+//     \fn void TQTimeEdit::valueChanged( const TQTime& time )
+//
+//     This signal is emitted whenever the editor's value changes. The \a
+//     time parameter is the new value.
+// */
+//
+// /*! \reimp
+//
+// */
+//
+// bool TQTimeEdit::event( TQEvent *e )
+// {
+//     if ( e->type() == TQEvent::FocusOut ) {
+// 	d->typing = FALSE;
+// 	if ( d->changed ) {
+// 	    emit valueChanged( time() );
+// 	    d->changed = FALSE;
+// 	}
+//     } else if ( e->type() == TQEvent::LocaleChange ) {
+// 	readLocaleSettings();
+// 	d->ed->setSeparator( localTimeSep() );
+//     }
+//     return ExtDateTimeEditBase::event( e );
+// }
+//
+// /*! \reimp
+//
+// */
+//
+// void TQTimeEdit::timerEvent( TQTimerEvent * )
+// {
+//     d->overwrite = TRUE;
+// }
+//
+//
+// /*! \reimp
+//
+// */
+//
+// void TQTimeEdit::stepUp()
+// {
+//     int sec = d->ed->mapSection( d->ed->focusSection() );
+//     bool accepted = TRUE;
+//     switch( sec ) {
+//     case 0:
+// 	if ( !outOfRange( d->h+1, d->m, d->s ) )
+// 	    setHour( d->h+1 );
+// 	else
+// 	    setHour( d->min.hour() );
+// 	break;
+//     case 1:
+// 	if ( !outOfRange( d->h, d->m+1, d->s ) )
+// 	    setMinute( d->m+1 );
+// 	else
+// 	    setMinute( d->min.minute() );
+// 	break;
+//     case 2:
+// 	if ( !outOfRange( d->h, d->m, d->s+1 ) )
+// 	    setSecond( d->s+1 );
+// 	else
+// 	    setSecond( d->min.second() );
+// 	break;
+//     case 3:
+// 	if ( d->h < 12 )
+// 	    setHour( d->h+12 );
+// 	else
+// 	    setHour( d->h-12 );
+// 	break;
+//     default:
+// 	accepted = FALSE;
+// #ifdef TQT_CHECK_RANGE
+// 	qWarning( "TQTimeEdit::stepUp: Focus section out of range!" );
+// #endif
+// 	break;
+//     }
+//     if ( accepted ) {
+// 	d->changed = TRUE;
+// 	emit valueChanged( time() );
+//     }
+//     d->ed->tqrepaint( d->ed->rect(), FALSE );
+// }
+//
+//
+// /*! \reimp
+//
+// */
+//
+// void TQTimeEdit::stepDown()
+// {
+//     int sec = d->ed->mapSection( d->ed->focusSection() );
+//
+//     bool accepted = TRUE;
+//     switch( sec ) {
+//     case 0:
+// 	if ( !outOfRange( d->h-1, d->m, d->s ) )
+// 	    setHour( d->h-1 );
+// 	else
+// 	    setHour( d->max.hour() );
+// 	break;
+//     case 1:
+// 	if ( !outOfRange( d->h, d->m-1, d->s ) )
+// 	    setMinute( d->m-1 );
+// 	else
+// 	    setMinute( d->max.minute() );
+// 	break;
+//     case 2:
+// 	if ( !outOfRange( d->h, d->m, d->s-1 ) )
+// 	    setSecond( d->s-1 );
+// 	else
+// 	    setSecond( d->max.second() );
+// 	break;
+//     case 3:
+// 	if ( d->h > 11 )
+// 	    setHour( d->h-12 );
+// 	else
+// 	    setHour( d->h+12 );
+// 	break;
+//     default:
+// 	accepted = FALSE;
+// #ifdef TQT_CHECK_RANGE
+// 	qWarning( "TQTimeEdit::stepDown: Focus section out of range!" );
+// #endif
+// 	break;
+//     }
+//     if ( accepted ) {
+// 	d->changed = TRUE;
+// 	emit valueChanged( time() );
+//     }
+//     d->ed->tqrepaint( d->ed->rect(), FALSE );
+// }
+//
+//
+// /*!
+//     Returns the formatted number for section \a sec. This will
+//     correspond to either the hour, minute or second section, depending
+//     on \a sec.
+// */
+//
+// TQString TQTimeEdit::sectionFormattedText( int sec )
+// {
+//     TQString txt;
+//     txt = sectionText( sec );
+//     txt = txt.rightJustify( 2, EXTDATETIMEEDIT_HIDDEN_CHAR );
+//     int offset = sec*2+sec*separator().length() + txt.length();
+//     if ( d->typing && sec == d->ed->focusSection() )
+// 	d->ed->setSectionSelection( sec, offset - txt.length(), offset );
+//     else
+// 	d->ed->setSectionSelection( sec, offset - txt.length(), offset );
+//
+//     return txt;
+// }
+//
+//
+// /*! \reimp
+//
+// */
+//
+// bool TQTimeEdit::setFocusSection( int sec )
+// {
+//     if ( sec != d->ed->focusSection() ) {
+// 	killTimer( d->timerId );
+// 	d->overwrite = TRUE;
+// 	d->typing = FALSE;
+// 	TQString txt = sectionText( sec );
+// 	txt = txt.rightJustify( 2, EXTDATETIMEEDIT_HIDDEN_CHAR );
+// 	int offset = sec*2+sec*separator().length() + txt.length();
+// 	d->ed->setSectionSelection( sec, offset - txt.length(), offset );
+// 	if ( d->changed ) {
+// 	    emit valueChanged( time() );
+// 	    d->changed = FALSE;
+// 	}
+//     }
+//     return d->ed->setFocusSection( sec );
+// }
+//
+//
+// /*!
+//     Sets the hour to \a h, which must be a valid hour, i.e. in the
+//     range 0..24.
+// */
+//
+// void TQTimeEdit::setHour( int h )
+// {
+//     if ( h < 0 )
+// 	h = 0;
+//     if ( h > 23 )
+// 	h = 23;
+//     d->h = h;
+// }
+//
+//
+// /*!
+//     Sets the minute to \a m, which must be a valid minute, i.e. in the
+//     range 0..59.
+// */
+//
+// void TQTimeEdit::setMinute( int m )
+// {
+//     if ( m < 0 )
+// 	m = 0;
+//     if ( m > 59 )
+// 	m = 59;
+//     d->m = m;
+// }
+//
+//
+// /*!
+//     Sets the second to \a s, which must be a valid second, i.e. in the
+//     range 0..59.
+// */
+//
+// void TQTimeEdit::setSecond( int s )
+// {
+//     if ( s < 0 )
+// 	s = 0;
+//     if ( s > 59 )
+// 	s = 59;
+//     d->s = s;
+// }
+//
+//
+// /*! \internal
+//
+//   Returns the text of section \a sec.
+//
+// */
+//
+// TQString TQTimeEdit::sectionText( int sec )
+// {
+//     sec = d->ed->mapSection( sec );
+//
+//     TQString txt;
+//     switch( sec ) {
+//     case 0:
+// 	if ( !(d->display & AMPM) || ( d->h < 13 && d->h ) ) {    // I wished the day stared at 0:00 for everybody
+// 	    txt = TQString::number( d->h );
+// 	} else {
+// 	    if ( d->h )
+// 		txt = TQString::number( d->h - 12 );
+// 	    else
+// 		txt = "12";
+// 	}
+// 	break;
+//     case 1:
+// 	txt = TQString::number( d->m );
+// 	break;
+//     case 2:
+// 	txt = TQString::number( d->s );
+// 	break;
+//     case 3:
+// 	if ( d->h < 12 ) {
+// 	    if ( lAM )
+// 		txt = *lAM;
+// 	    else
+// 		txt = TQString::tqfromLatin1( "AM" );
+// 	} else {
+// 	    if ( lPM )
+// 		txt = *lPM;
+// 	    else
+// 		txt = TQString::tqfromLatin1( "PM" );
+// 	}
+// 	break;
+//     default:
+// 	break;
+//     }
+//     return txt;
+// }
+//
+//
+// /*! \internal
+//  Returns TRUE if \a h, \a m, and \a s are out of range.
+//  */
+//
+// bool TQTimeEdit::outOfRange( int h, int m, int s ) const
+// {
+//     if ( TQTime::isValid( h, m, s ) ) {
+// 	TQTime currentTime( h, m, s );
+// 	if ( currentTime > maxValue() ||
+// 	     currentTime < minValue() )
+// 	    return TRUE;
+// 	else
+// 	    return FALSE;
+//     }
+//     return TRUE;
+// }
+//
+// /*! \reimp
+//
+// */
+//
+// void TQTimeEdit::addNumber( int sec, int num )
+// {
+//     if ( sec == -1 )
+// 	return;
+//     sec = d->ed->mapSection( sec );
+//     killTimer( d->timerId );
+//     bool overwrite = FALSE;
+//     bool accepted = FALSE;
+//     d->typing = TRUE;
+//     TQString txt;
+//
+//     switch( sec ) {
+//     case 0:
+// 	txt = ( d->display & AMPM && d->h > 12 ) ?
+// 	    TQString::number( d->h - 12 ) : TQString::number( d->h );
+//
+// 	if ( d->overwrite || txt.length() == 2 ) {
+// 	    if ( d->display & AMPM && num == 0 )
+// 		break; // Don't process 0 in 12 hour clock mode
+// 	    if ( d->display & AMPM && d->h > 11 )
+// 		num += 12;
+// 	    if ( !outOfRange( num, d->m, d->s ) ) {
+// 		accepted = TRUE;
+// 		d->h = num;
+// 	    }
+// 	} else {
+// 	    txt += TQString::number( num );
+// 	    int temp = txt.toInt();
+//
+// 	    if ( d->display & AMPM ) {
+// 		if ( temp == 12 ) {
+// 		    if ( d->h < 12 ) {
+// 			temp = 0;
+// 		    }
+// 		    accepted = TRUE;
+// 		} else if ( outOfRange( temp + 12, d->m, d->s ) ) {
+// 		    txt = TQString::number( d->h );
+// 		} else {
+// 		    if ( d->h > 11 ) {
+// 			temp += 12;
+// 		    }
+// 		    accepted = TRUE;
+// 		}
+// 	    } else if ( !(d->display & AMPM) && outOfRange( temp, d->m, d->s ) ) {
+// 		txt = TQString::number( d->h );
+// 	    } else {
+// 		accepted = TRUE;
+// 	    }
+//
+// 	    if ( accepted )
+// 		d->h = temp;
+//
+// 	    if ( d->adv && txt.length() == 2 ) {
+// 		setFocusSection( d->ed->focusSection()+1 );
+// 		overwrite = TRUE;
+// 	    }
+// 	}
+// 	break;
+//
+//     case 1:
+// 	txt = TQString::number( d->m );
+// 	if ( d->overwrite || txt.length() == 2 ) {
+// 	    if ( !outOfRange( d->h, num, d->s ) ) {
+// 		accepted = TRUE;
+// 		d->m = num;
+// 	    }
+// 	} else {
+// 	    txt += TQString::number( num );
+// 	    int temp = txt.toInt();
+// 	    if ( temp > 59 )
+// 		temp = num;
+// 	    if ( outOfRange( d->h, temp, d->s ) )
+// 		txt = TQString::number( d->m );
+// 	    else {
+// 		accepted = TRUE;
+// 		d->m = temp;
+// 	    }
+// 	    if ( d->adv && txt.length() == 2 ) {
+// 		setFocusSection( d->ed->focusSection()+1 );
+// 		overwrite = TRUE;
+// 	    }
+// 	}
+// 	break;
+//
+//     case 2:
+// 	txt = TQString::number( d->s );
+// 	if ( d->overwrite || txt.length() == 2 ) {
+// 	    if ( !outOfRange( d->h, d->m, num ) ) {
+// 		accepted = TRUE;
+// 		d->s = num;
+// 	    }
+// 	} else {
+// 	    txt += TQString::number( num );
+// 	    int temp = txt.toInt();
+// 	    if ( temp > 59 )
+// 		temp = num;
+// 	    if ( outOfRange( d->h, d->m, temp ) )
+// 		txt = TQString::number( d->s );
+// 	    else {
+// 		accepted = TRUE;
+// 		d->s = temp;
+// 	    }
+// 	    if ( d->adv && txt.length() == 2 ) {
+// 		setFocusSection( d->ed->focusSection()+1 );
+// 		overwrite = TRUE;
+// 	    }
+// 	}
+// 	break;
+//
+//     case 3:
+// 	break;
+//
+//     default:
+// 	break;
+//     }
+//     d->changed = accepted;
+//     if ( accepted )
+// 	emit valueChanged( time() );
+//     d->overwrite = overwrite;
+//     d->timerId = startTimer( tqApp->doubleClickInterval()*4 );
+//     d->ed->tqrepaint( d->ed->rect(), FALSE );
+// }
+//
+//
+// /*!
+//   \internal
+//
+//   Function which is called whenever the user tries to
+//   remove the first number from \a sec by pressing the backspace key.
+// */
+//
+// void TQTimeEdit::removeFirstNumber( int sec )
+// {
+//     if ( sec == -1 )
+// 	return;
+//     sec = d->ed->mapSection( sec );
+//     TQString txt;
+//     switch( sec ) {
+//     case 0:
+// 	txt = TQString::number( d->h );
+// 	break;
+//     case 1:
+// 	txt = TQString::number( d->m );
+// 	break;
+//     case 2:
+// 	txt = TQString::number( d->s );
+// 	break;
+//     }
+//     txt = txt.mid( 1, txt.length() ) + "0";
+//     switch( sec ) {
+//     case 0:
+// 	d->h = txt.toInt();
+// 	break;
+//     case 1:
+// 	d->m = txt.toInt();
+// 	break;
+//     case 2:
+// 	d->s = txt.toInt();
+// 	break;
+//     }
+//     d->ed->tqrepaint( d->ed->rect(), FALSE );
+// }
+//
+// /*! \reimp
+//
+// */
+// void TQTimeEdit::removeLastNumber( int sec )
+// {
+//     if ( sec == -1 )
+// 	return;
+//     sec = d->ed->mapSection( sec );
+//     TQString txt;
+//     switch( sec ) {
+//     case 0:
+// 	txt = TQString::number( d->h );
+// 	break;
+//     case 1:
+// 	txt = TQString::number( d->m );
+// 	break;
+//     case 2:
+// 	txt = TQString::number( d->s );
+// 	break;
+//     }
+//     txt = txt.mid( 0, txt.length()-1 );
+//     switch( sec ) {
+//     case 0:
+// 	d->h = txt.toInt();
+// 	break;
+//     case 1:
+// 	d->m = txt.toInt();
+// 	break;
+//     case 2:
+// 	d->s = txt.toInt();
+// 	break;
+//     }
+//     d->ed->tqrepaint( d->ed->rect(), FALSE );
+// }
+//
+// /*! \reimp
+//  */
+// void TQTimeEdit::resizeEvent( TQResizeEvent * )
+// {
+//     d->controls->resize( width(), height() );
+// }
+//
+// /*! \reimp
+// */
+// TQSize TQTimeEdit::tqsizeHint() const
+// {
+//     constPolish();
+//     TQFontMetrics fm( font() );
+//     int fw = tqstyle().tqpixelMetric( TQStyle::PM_DefaultFrameWidth, this );
+//     int h = fm.lineSpacing() + 2;
+//     int w = 2 + fm.width( '9' ) * 6 + fm.width( d->ed->separator() ) * 2 +
+// 	d->controls->upRect().width() + fw * 4;
+//     if ( d->display & AMPM ) {
+// 	if ( lAM )
+// 	    w += fm.width( *lAM ) + 4;
+// 	else
+// 	    w += fm.width( TQString::tqfromLatin1( "AM" ) ) + 4;
+//     }
+//
+//     return TQSize( w, TQMAX(h + fw * 2,20) ).expandedTo( TQApplication::globalStrut() );
+// }
+//
+// /*! \reimp
+// */
+// TQSize TQTimeEdit::tqminimumSizeHint() const
+// {
+//     return tqsizeHint();
+// }
+//
+// /*!
+//     \internal
+//     Enables/disables the push buttons according to the min/max time
+//     for this widget.
+// */
+//
+// // ### Remove in 4.0?
+//
+// void TQTimeEdit::updateButtons()
+// {
+//     if ( !isEnabled() )
+// 	return;
+//
+//     bool upEnabled = time() < maxValue();
+//     bool downEnabled = time() > minValue();
+//
+//     d->controls->setUpEnabled( upEnabled );
+//     d->controls->setDownEnabled( downEnabled );
+// }
+
+
+class ExtDateTimeEditPrivate
+{
+public:
+    bool adv;
+};
+
+/*!
+    \class ExtDateTimeEdit ExtDatetimeedit.h
+    \brief The ExtDateTimeEdit class combines a ExtDateEdit and TQTimeEdit
+    widget into a single widget for editing datetimes.
+
+    \ingroup advanced
+    \ingroup time
+
+    ExtDateTimeEdit consists of a ExtDateEdit and TQTimeEdit widget placed
+    side by side and offers the functionality of both. The user can
+    edit the date and time by using the keyboard or the arrow keys to
+    increase/decrease date or time values. The Tab key can be used to
+    move from section to section within the ExtDateTimeEdit widget, and
+    the user can be moved automatically when they complete a section
+    using setAutoAdvance(). The datetime can be set with
+    setDateTime().
+
+    The date format is read from the system's locale settings. It is
+    set to year, month, day order if that is not possible. See
+    ExtDateEdit::setOrder() to change this. Times appear in the order
+    hours, minutes, seconds using the 24 hour clock.
+
+    It is recommended that the ExtDateTimeEdit is initialised with a
+    datetime, e.g.
+    \code
+    ExtDateTimeEdit *dateTimeEdit = new ExtDateTimeEdit( ExtDateTime::tqcurrentDateTime(), this );
+    dateTimeEdit->dateEdit()->setRange( ExtDateTime::tqcurrentDate(),
+					ExtDateTime::tqcurrentDate().addDays( 7 ) );
+    \endcode
+    Here we've created a new ExtDateTimeEdit set to the current date and
+    time, and set the date to have a minimum date of now and a maximum
+    date of a week from now.
+
+    Terminology: A ExtDateEdit widget consists of three 'sections', one
+    each for the year, month and day. Similarly a TQTimeEdit consists
+    of three sections, one each for the hour, minute and second. The
+    character that separates each date section is specified with
+    setDateSeparator(); similarly setTimeSeparator() is used for the
+    time sections.
+
+    \image html datetimewidgets.png "Date Time Widgets"
+
+    \sa ExtDateEdit TQTimeEdit
+*/
+
+/*!
+    Constructs an empty datetime edit with parent \a parent and called
+    \a name.
+*/
+ExtDateTimeEdit::ExtDateTimeEdit( TQWidget * parent, const char * name )
+    : TQWidget( parent, name )
+{
+    init();
+}
+
+
+/*!
+    \overload
+
+    Constructs a datetime edit with the initial value \a datetime,
+    parent \a parent and called \a name.
+*/
+ExtDateTimeEdit::ExtDateTimeEdit( const ExtDateTime& datetime,
+			      TQWidget * parent, const char * name )
+    : TQWidget( parent, name )
+{
+    init();
+    setDateTime( datetime );
+}
+
+
+
+/*!
+    Destroys the object and frees any allocated resources.
+*/
+
+ExtDateTimeEdit::~ExtDateTimeEdit()
+{
+    delete d;
+}
+
+
+/*!
+    \reimp
+
+    Intercepts and handles resize events which have special meaning
+    for the ExtDateTimeEdit.
+*/
+
+void ExtDateTimeEdit::resizeEvent( TQResizeEvent * )
+{
+    int dw = de->tqsizeHint().width();
+    int tw = te->tqsizeHint().width();
+    int w = width();
+    int h = height();
+    int extra = w - ( dw + tw );
+
+    if ( tw + extra < 0 ) {
+	dw = w;
+    } else {
+	dw += 9 * extra / 16;
+    }
+    tw = w - dw;
+
+    de->setGeometry( 0, 0, dw, h );
+    te->setGeometry( dw, 0, tw, h );
+}
+
+/*! \reimp
+*/
+
+TQSize ExtDateTimeEdit::tqminimumSizeHint() const
+{
+    TQSize dsh = de->tqminimumSizeHint();
+    TQSize tsh = te->tqminimumSizeHint();
+    return TQSize( dsh.width() + tsh.width(),
+		  TQMAX( dsh.height(), tsh.height() ) );
+}
+
+/*!  \internal
+ */
+
+void ExtDateTimeEdit::init()
+{
+    d = new ExtDateTimeEditPrivate();
+    de = new ExtDateEdit( this, "qt_datetime_dateedit" );
+    te = new TQTimeEdit( this, "qt_datetime_timeedit" );
+    d->adv = FALSE;
+    connect( de, TQT_SIGNAL( valueChanged( const ExtDate& ) ),
+	     this, TQT_SLOT( newValue( const ExtDate& ) ) );
+    connect( te, TQT_SIGNAL( valueChanged( const TQTime& ) ),
+	     this, TQT_SLOT( newValue( const TQTime& ) ) );
+    setFocusProxy( de );
+    tqsetSizePolicy( TQSizePolicy::Minimum, TQSizePolicy::Fixed );
+}
+
+/*! \reimp
+ */
+
+TQSize ExtDateTimeEdit::tqsizeHint() const
+{
+    constPolish();
+    TQSize dsh = de->tqsizeHint();
+    TQSize tsh = te->tqsizeHint();
+    return TQSize( dsh.width() + tsh.width(),
+		  TQMAX( dsh.height(), tsh.height() ) );
+}
+
+/*!
+    \property ExtDateTimeEdit::dateTime
+    \brief the editor's datetime value
+
+    The datetime edit's datetime which may be an invalid datetime.
+*/
+
+void ExtDateTimeEdit::setDateTime( const ExtDateTime & dt )
+{
+    if ( dt.isValid() ) {
+	de->setDate( dt.date() );
+	te->setTime( dt.time() );
+	emit valueChanged( dt );
+    }
+}
+
+ExtDateTime ExtDateTimeEdit::dateTime() const
+{
+    return ExtDateTime( de->date(), te->time() );
+}
+
+/*!
+    \fn void ExtDateTimeEdit::valueChanged( const ExtDateTime& datetime )
+
+    This signal is emitted every time the date or time changes. The \a
+    datetime argument is the new datetime.
+*/
+
+
+/*! \internal
+
+  Re-emits the value \a d.
+ */
+
+void ExtDateTimeEdit::newValue( const ExtDate& )
+{
+    ExtDateTime dt = dateTime();
+    emit valueChanged( dt );
+}
+
+/*! \internal
+  \overload
+  Re-emits the value \a t.
+ */
+
+void ExtDateTimeEdit::newValue( const TQTime& )
+{
+    ExtDateTime dt = dateTime();
+    emit valueChanged( dt );
+}
+
+
+/*!
+    Sets the auto advance property of the editor to \a advance. If set
+    to TRUE, the editor will automatically advance focus to the next
+    date or time section if the user has completed a section.
+*/
+
+void ExtDateTimeEdit::setAutoAdvance( bool advance )
+{
+    de->setAutoAdvance( advance );
+    te->setAutoAdvance( advance );
+}
+
+/*!
+    Returns TRUE if auto-advance is enabled, otherwise returns FALSE.
+
+    \sa setAutoAdvance()
+*/
+
+bool ExtDateTimeEdit::autoAdvance() const
+{
+    return de->autoAdvance();
+}
+
+/*!
+    \fn ExtDateEdit* ExtDateTimeEdit::dateEdit()
+
+    Returns the internal widget used for editing the date part of the
+    datetime.
+*/
+
+/*!
+    \fn TQTimeEdit* ExtDateTimeEdit::timeEdit()
+
+    Returns the internal widget used for editing the time part of the
+    datetime.
+*/
+
+#include "extdatetimeedit.moc"
+
+#endif