tdevelop/kdevdesigner/designer/widgetfactory.cpp

/**********************************************************************
** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
**
** This file is part of TQt Designer.
**
** 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.
**
** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition
** licenses may use this file in accordance with the TQt Commercial License
** Agreement provided with the Software.
**
** 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.
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
**   information about TQt Commercial License Agreements.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/

#include <tqvariant.h> // HP-UX compiler need this here
#include "widgetfactory.h"
#include <widgetdatabase.h>
#include "metadatabase.h"
#include "mainwindow.h"
#include "formwindow.h"
#include "propertyeditor.h"
#include "tqlayout.h"
#include "listboxeditorimpl.h"
#include "listvieweditorimpl.h"
#include "iconvieweditorimpl.h"
#include "formwindow.h"
#include "multilineeditorimpl.h"
#include "../interfaces/widgetinterface.h"
#ifndef TQT_NO_TABLE
#include "tableeditorimpl.h"
#endif
#include "project.h"
#include "menubareditor.h"
#include "popupmenueditor.h"

#include "kdevdesigner_part.h"

#include <kiconloader.h>

#include <tqfeatures.h>

#include <tqpixmap.h>
#include <tqgroupbox.h>
#include <tqiconview.h>
#ifndef TQT_NO_TABLE
#include <tqtable.h>
#endif
#ifndef TQT_NO_SQL
#include <tqdatatable.h>
#endif
#include <tqdatetimeedit.h>
#include <tqlineedit.h>
#include <tqspinbox.h>
#include <tqmultilineedit.h>
#include <tqtextedit.h>
#include <tqlabel.h>
#include <tqlayout.h>
#include <tqwidgetstack.h>
#include <tqcombobox.h>
#include <tqtabbar.h>
#include <tqlistbox.h>
#include <tqlistview.h>
#include <tqobjectlist.h>
#include <tqlcdnumber.h>
#include <tqslider.h>
#include <tqdial.h>
#include <tqprogressbar.h>
#include <tqtextview.h>
#include <tqtextbrowser.h>
#include <tqframe.h>
#include <tqmetaobject.h>
#include <tqwidgetstack.h>
#include <tqwizard.h>
#include <tqvaluelist.h>
#include <tqtimer.h>
#include <tqscrollbar.h>
#include <tqmainwindow.h>
#include <tqmenubar.h>
#include <tqapplication.h>
#include <tqsplitter.h>
#include <tqtoolbox.h>
#include <tqsizegrip.h>
#ifndef TQT_NO_SQL
#include "database.h"
#endif

#define NO_STATIC_COLORS
#include <globaldefs.h>
#include <tqobject.h>

#include <tdelocale.h>

FormWindow *find_formwindow( TQWidget *w )
{
    if ( !w )
	return 0;
    for (;;) {
	if ( ::tqt_cast<FormWindow*>(w) )
	    return (FormWindow*)w;
	if ( !w->parentWidget() )
	    return 0;
	w = w->parentWidget();
    }
}

void TQLayoutWidget::paintEvent( TQPaintEvent* )
{
    TQPainter p ( this );
    p.setPen( red );
    p.drawRect( rect() );
}


QDesignerTabWidget::QDesignerTabWidget( TQWidget *parent, const char *name )
    : TQTabWidget( parent, name ), dropIndicator( 0 ), dragPage( 0 ), mousePressed( FALSE )
{
    tabBar()->setAcceptDrops( TRUE );
    tabBar()->installEventFilter( this );
}

int QDesignerTabWidget::currentPage() const
{
    return tabBar()->currentTab();
}

void QDesignerTabWidget::setCurrentPage( int i )
{
    tabBar()->setCurrentTab( i );
}

TQString QDesignerTabWidget::pageTitle() const
{
    return ((TQTabWidget*)this)->tabLabel( TQTabWidget::currentPage() );
}

void QDesignerTabWidget::setPageTitle( const TQString& title )
{
    changeTab( TQTabWidget::currentPage(), title );
}

void QDesignerTabWidget::setPageName( const TQCString& name )
{
    if ( TQTabWidget::currentPage() )
	TQTabWidget::currentPage()->setName( name );
}

TQCString QDesignerTabWidget::pageName() const
{
    if ( !TQTabWidget::currentPage() )
	return 0;
    return TQTabWidget::currentPage()->name();
}

int QDesignerTabWidget::count() const
{
    return tabBar()->count();
}

bool QDesignerTabWidget::eventFilter( TQObject *o, TQEvent *e )
{
    if ( o != tabBar() ) return FALSE;

    switch ( e->type() ) {
    case TQEvent::MouseButtonPress: {
	mousePressed = TRUE;
	TQMouseEvent *me = (TQMouseEvent*)e;
	pressPoint = me->pos();
    }
    break;
    case TQEvent::MouseMove: {
	TQMouseEvent *me = (TQMouseEvent*)e;
	if ( mousePressed && ( pressPoint - me->pos()).manhattanLength() > TQApplication::startDragDistance() ) {
	    TQTextDrag *drg = new TQTextDrag( TQString::number( (long) this ) , this );
	    mousePressed = FALSE;
	    dragPage = TQTabWidget::currentPage();
	    dragLabel = TQTabWidget::tabLabel( dragPage );

	    int index = indexOf( dragPage );

	    removePage( dragPage );
	    if ( !drg->dragMove() ) {
		insertTab( dragPage, dragLabel, index );
		showPage( dragPage );
	    }
	    if ( dropIndicator )
		dropIndicator->hide();
	}
    }
    break;
    case TQEvent::DragLeave:	{
	if ( dropIndicator )
	    dropIndicator->hide();
    }
    break;
    case TQEvent::DragMove: {
	TQDragEnterEvent *de = (TQDragEnterEvent*) e;
	if ( TQTextDrag::canDecode( de ) ) {
	    TQString text;
	    TQTextDrag::decode( de, text );
	    if ( text == TQString::number( (long)this ) )
		de->accept();
	    else
		return FALSE;
	}

	int index = 0;
	TQRect rect;
	for ( ; index < tabBar()->count(); index++ ) {
	    if ( tabBar()->tabAt( index )->rect().contains( de->pos() ) ) {
		rect = tabBar()->tabAt( index )->rect();
		break;
	    }
	}

	if ( index == tabBar()->count() -1 ) {
	    TQRect rect2 = rect;
	    rect2.setLeft( rect2.left() + rect2.width() / 2 );
	    if ( rect2.contains( de->pos() ) )
		index++;
	}

	if ( ! dropIndicator ) {
	    dropIndicator = new TQWidget( this );
	    dropIndicator->setBackgroundColor( red );
	}

	TQPoint pos;
	if ( index == tabBar()->count() )
	    pos = tabBar()->mapToParent( TQPoint( rect.x() + rect.width(), rect.y() ) );
	else
	    pos = tabBar()->mapToParent( TQPoint( rect.x(), rect.y() ) );

	dropIndicator->setGeometry( pos.x(), pos.y() , 3, rect.height() );
	dropIndicator->show();
    }
    break;
    case TQEvent::Drop: {
	TQDragEnterEvent *de = (TQDragEnterEvent*) e;
	if ( TQTextDrag::canDecode( de ) ) {
	    TQString text;
	    TQTextDrag::decode( de, text );
	    if ( text == TQString::number( (long)this ) ) {

		int newIndex = 0;
		for ( ; newIndex < tabBar()->count(); newIndex++ ) {
		    if ( tabBar()->tabAt( newIndex )->rect().contains( de->pos() ) )
			break;
		}

		if ( newIndex == tabBar()->count() -1 ) {
		    TQRect rect2 = tabBar()->tabAt( newIndex )->rect();
		    rect2.setLeft( rect2.left() + rect2.width() / 2 );
		    if ( rect2.contains( de->pos() ) )
			newIndex++;
		}

		int oldIndex = 0;
		for ( ; oldIndex < tabBar()->count(); oldIndex++ ) {
		    if ( tabBar()->tabAt( oldIndex )->rect().contains( pressPoint ) )
			break;
		}

		FormWindow *fw = find_formwindow( this );
		MoveTabPageCommand *cmd =
		    new MoveTabPageCommand( i18n( "Move Tab Page" ), fw, this,
					    dragPage, dragLabel, newIndex, oldIndex );
		fw->commandHistory()->addCommand( cmd );
		cmd->execute();
		de->accept();
	    }
	}
    }
    break;
    default:
	break;
    }
    return FALSE;
}


QDesignerWidgetStack::QDesignerWidgetStack( TQWidget *parent, const char *name )
    : TQWidgetStack( parent, name )
{
    prev = new TQToolButton( TQt::LeftArrow, this, "designer_wizardstack_button" );
    prev->setAutoRaise( TRUE );
    prev->setAutoRepeat( TRUE );
    prev->setSizePolicy( TQSizePolicy( TQSizePolicy::Ignored, TQSizePolicy::Ignored ) );
    next = new TQToolButton( TQt::RightArrow, this, "designer_wizardstack_button" );
    next->setAutoRaise( TRUE );
    next->setAutoRepeat( TRUE );
    next->setSizePolicy( TQSizePolicy( TQSizePolicy::Ignored, TQSizePolicy::Ignored ) );
    connect( prev, TQ_SIGNAL( clicked() ), this, TQ_SLOT( prevPage() ) );
    connect( next, TQ_SIGNAL( clicked() ), this, TQ_SLOT( nextPage() ) );
    updateButtons();
}

void QDesignerWidgetStack::updateButtons()
{
    prev->setGeometry( width() - 31, 1, 15, 15 );
    next->setGeometry( width() - 16, 1, 15, 15 );
    prev->show();
    next->show();
    prev->raise();
    next->raise();
}

void QDesignerWidgetStack::prevPage()
{
    setCurrentPage( currentPage() - 1 );
}

void QDesignerWidgetStack::nextPage()
{
    setCurrentPage( currentPage() + 1 );
}

int QDesignerWidgetStack::currentPage() const
{
    QDesignerWidgetStack* that = (QDesignerWidgetStack*) this;
    return that->pages.find( visibleWidget() );
}

void QDesignerWidgetStack::setCurrentPage( int i )
{
    // help next/prev page commands
    if ( i < 0 )
	i += count();
    if ( i >= count() )
	i -= count();

    if ( i < 0 || i >= count() )
	return;
    raiseWidget( pages.at( i ) );
    updateButtons();
}

TQCString QDesignerWidgetStack::pageName() const
{
    if ( !visibleWidget() )
	return 0;
    return visibleWidget()->name();
}

void QDesignerWidgetStack::setPageName( const TQCString& name )
{
    if ( visibleWidget() )
	visibleWidget()->setName( name );
}

int QDesignerWidgetStack::count() const
{
    return pages.count();
}

TQWidget* QDesignerWidgetStack::page( int i ) const
{
    if ( i < 0 || i >= count() )
	return 0;
    QDesignerWidgetStack* that = (QDesignerWidgetStack*) this;
    return that->pages.at( i );
}


int QDesignerWidgetStack::insertPage( TQWidget *p, int i )
{
    if ( i < 0 )
	pages.append( p );
    else
	pages.insert( (uint) i, p );
    addWidget( p );
    p->show();
    raiseWidget( p );
    TQApplication::sendPostedEvents();
    updateButtons();
    return pages.find( p );
}

int QDesignerWidgetStack::removePage( TQWidget *p )
{
    int i = pages.find( p );
    pages.remove( p );
    removeWidget( p );
    setCurrentPage( 0 );
    updateButtons();
    return i;
}


int QDesignerWizard::currentPageNum() const
{
    for ( int i = 0; i < pageCount(); ++i ) {
	if ( page( i ) == currentPage() )
	    return i;
    }
    return 0;
}





void QDesignerWizard::setCurrentPage( int i )
{
    if ( i < currentPageNum() ) {
	while ( i < currentPageNum() ) {
	    if ( currentPageNum() == 0 )
		break;
	    back();
	}

    } else {
	while ( i > currentPageNum() ) {
	    if ( currentPageNum() == pageCount() - 1 )
		break;
	    next();
	}
    }
}

TQString QDesignerWizard::pageTitle() const
{
    return title( currentPage() );
}

void QDesignerWizard::setPageTitle( const TQString& title )
{
    setTitle( currentPage(), title );
}

void QDesignerWizard::setPageName( const TQCString& name )
{
    if ( TQWizard::currentPage() )
	TQWizard::currentPage()->setName( name );
}

TQCString QDesignerWizard::pageName() const
{
    if ( !TQWizard::currentPage() )
	return 0;
    return TQWizard::currentPage()->name();
}

int QDesignerWizard::pageNum( TQWidget *p )
{
    for ( int i = 0; i < pageCount(); ++i ) {
	if ( page( i ) == p )
	    return i;
    }
    return -1;
}

void QDesignerWizard::addPage( TQWidget *p, const TQString &t )
{
    TQWizard::addPage( p, t );
    if ( removedPages.find( p ) )
	removedPages.remove( p );
}

void QDesignerWizard::removePage( TQWidget *p )
{
    TQWizard::removePage( p );
    removedPages.insert( p, p );
}

void QDesignerWizard::insertPage( TQWidget *p, const TQString &t, int index )
{
    TQWizard::insertPage( p, t, index );
    if ( removedPages.find( p ) )
	removedPages.remove( p );
}

TQMap< int, TQMap< TQString, TQVariant> > *defaultProperties = 0;
TQMap< int, TQStringList > *changedProperties = 0;

/*!
  \class WidgetFactory widgetfactory.h
  \brief Set of static functions for creating widgets, layouts and do other stuff

  The widget factory offers functions to create widgets, create and
  delete layouts find out other details - all based on the
  WidgetDatabase's data. So the functions that use ids use the same
  ids as in the WidgetDatabase.
*/


void WidgetFactory::saveDefaultProperties( TQObject *w, int id )
{
    TQMap< TQString, TQVariant> propMap;
    TQStrList lst = w->metaObject()->propertyNames( TRUE );
    for ( uint i = 0; i < lst.count(); ++i ) {
	TQVariant var = w->property( lst.at( i ) );
	if ( !var.isValid() && qstrcmp( "pixmap", lst.at( i ) ) == 0 )
	    var = TQVariant( TQPixmap() );
	else if ( !var.isValid() && qstrcmp( "iconSet", lst.at( i ) ) == 0 )
	    var = TQVariant( TQIconSet() );
	propMap.replace( lst.at( i ), var );
    }
    defaultProperties->replace( id, propMap );
}

void WidgetFactory::saveChangedProperties( TQObject *w, int id )
{
    TQStringList l = MetaDataBase::changedProperties( w );
    changedProperties->insert( id, l );
}

/*!  Creates a widget of the type which is registered as \a id as
  child of \a parent. The \a name is optional. If \a init is TRUE, the
  widget is initialized with some defaults, else the plain widget is
  created.
*/

TQWidget *WidgetFactory::create( int id, TQWidget *parent, const char *name, bool init, const TQRect *r, TQt::Orientation orient )
{
    TQString n = WidgetDatabase::className( id );
    if ( n.isEmpty() )
	return 0;

    if ( !defaultProperties ) {
	defaultProperties = new TQMap< int, TQMap< TQString, TQVariant> >();
	changedProperties = new TQMap< int, TQStringList >();
    }

    TQWidget *w = 0;
    TQString str = WidgetDatabase::createWidgetName( id );
    const char *s = str.latin1();
    w = createWidget( n, parent, name ? name : s, init, r, orient );
    if ( ::tqt_cast<TQScrollView*>(w) )
	( (TQScrollView*)w )->disableSizeHintCaching();
    if ( !w && WidgetDatabase::isCustomWidget( id ) )
	w = createCustomWidget( parent, name ? name : s, MetaDataBase::customWidget( id ) );
    if ( !w )
	return 0;
    MetaDataBase::addEntry( w );

    if ( !defaultProperties->contains( id ) )
	saveDefaultProperties( w, id );
    if ( !changedProperties->contains( id ) )
	saveChangedProperties( w, id );

    return w;
}

/*!  Creates a layout on the widget \a widget of the type \a type
  which can be \c HBox, \c VBox or \c Grid.
*/

TQLayout *WidgetFactory::createLayout( TQWidget *widget, TQLayout *layout, LayoutType type )
{
    int spacing = MainWindow::self->currentLayoutDefaultSpacing();
    int margin = 0;

    int metaspacing = MetaDataBase::spacing( widget );
    int metamargin = MetaDataBase::margin( widget );

    if ( ::tqt_cast<TQLayoutWidget*>(widget) &&
	 ( WidgetDatabase::isContainer( WidgetDatabase::idFromClassName( WidgetFactory::classNameOf( widget ) ) ) ||
	   widget && ::tqt_cast<FormWindow*>(widget->parentWidget()) ) )
	margin = MainWindow::self->currentLayoutDefaultMargin();

    if ( !layout && ::tqt_cast<TQTabWidget*>(widget) )
	widget = ((TQTabWidget*)widget)->currentPage();

    if ( !layout && ::tqt_cast<TQWizard*>(widget) )
	widget = ((TQWizard*)widget)->currentPage();

    if ( !layout && ::tqt_cast<TQMainWindow*>(widget) )
	widget = ((TQMainWindow*)widget)->centralWidget();

    if ( !layout && ::tqt_cast<TQWidgetStack*>(widget) )
	widget = ((TQWidgetStack*)widget)->visibleWidget();

    if ( !layout && ::tqt_cast<TQToolBox*>(widget) )
	widget = ((TQToolBox*)widget)->currentItem();

    MetaDataBase::addEntry( widget );

    TQLayout *l = 0;
    int align = 0;
    if ( !layout && ::tqt_cast<TQGroupBox*>(widget) ) {
	TQGroupBox *gb = (TQGroupBox*)widget;
	gb->setColumnLayout( 0, TQt::Vertical );
	layout = gb->layout();
	layout->setMargin( 0 );
	layout->setSpacing( 0 );
	switch ( type ) {
	case HBox:
	    l = new TQHBoxLayout( layout );
	    break;
	case VBox:
	    l = new TQVBoxLayout( layout );
	    break;
	case Grid:
	    l = new QDesignerGridLayout( layout );
	    break;
	default:
	    return 0;
	}
	align = TQt::AlignTop;
	MetaDataBase::setMargin( gb, metamargin );
	MetaDataBase::setSpacing( gb, metaspacing );
    } else {
	if ( layout ) {
	    switch ( type ) {
	    case HBox:
		l = new TQHBoxLayout( layout );
		break;
	    case VBox:
		l = new TQVBoxLayout( layout );
		break;
	    case Grid:
		l = new QDesignerGridLayout( layout );
		break;
	    default:
		return 0;
	    }
	    MetaDataBase::addEntry( l );
	    l->setSpacing( spacing );
	    l->setMargin( margin );
	} else {
	    switch ( type ) {
	    case HBox:
		l = new TQHBoxLayout( widget );
		break;
	    case VBox:
		l = new TQVBoxLayout( widget );
		break;
	    case Grid:
		l = new QDesignerGridLayout( widget );
		break;
	    default:
		return 0;
	    }
	    MetaDataBase::addEntry( l );
	    if ( widget ) {
		MetaDataBase::setMargin( widget, metamargin );
		MetaDataBase::setSpacing( widget, metaspacing );
	    } else {
		l->setMargin( margin );
		l->setSpacing( spacing );
	    }
	}
    }
    l->setAlignment( align );
    MetaDataBase::addEntry( l );
    return l;
}

void WidgetFactory::deleteLayout( TQWidget *widget )
{
    if ( !widget )
	return;

    if ( ::tqt_cast<TQTabWidget*>(widget) )
	widget = ((TQTabWidget*)widget)->currentPage();
    if ( ::tqt_cast<TQWizard*>(widget) )
	widget = ((TQWizard*)widget)->currentPage();
    if ( ::tqt_cast<TQMainWindow*>(widget) )
	widget = ((TQMainWindow*)widget)->centralWidget();
    if ( ::tqt_cast<TQWidgetStack*>(widget) )
	widget = ((TQWidgetStack*)widget)->visibleWidget();
    if ( ::tqt_cast<TQToolBox*>(widget) )
	widget = ((TQToolBox*)widget)->currentItem();
    delete widget->layout();
}

/*!  Factory functions for creating a widget of the type \a className
  as child of \a parent with the name \a name.

  If \a init is TRUE, some initial default properties are set. This
  has to be in sync with the initChangedProperties() function!
*/

TQWidget *WidgetFactory::createWidget( const TQString &className, TQWidget *parent, const char *name, bool init,
				      const TQRect *r, TQt::Orientation orient )
{
    if ( className == "TQPushButton" ) {
	TQPushButton *b = 0;
	if ( init ) {
	    b = new QDesignerPushButton( parent, name );
	    b->setText( TQString::fromLatin1( name ) );
	} else {
	    b = new QDesignerPushButton( parent, name );
	}
	TQWidget *w = find_formwindow( b );
	b->setAutoDefault( w && ::tqt_cast<TQDialog*>(((FormWindow*)w)->mainContainer()) );
	return b;
    } else if ( className == "TQToolButton" ) {
	if ( init ) {
	    QDesignerToolButton *tb = new QDesignerToolButton( parent, name );
	    if ( ::tqt_cast<TQToolBox*>(widgetOfContainer(parent))) {
		tb->setUsesTextLabel(TRUE);
		tb->setTextLabel("...");
		tb->setAutoRaise(TRUE);
		tb->setTextPosition(TQToolButton::BesideIcon);
	    } else {
		tb->setText( "..." );
	    }
	    return tb;
	}
	return new QDesignerToolButton( parent, name );
    } else if ( className == "TQCheckBox" ) {
	if ( init ) {
	    QDesignerCheckBox *cb = new QDesignerCheckBox( parent, name );
	    cb->setText( TQString::fromLatin1( name ) );
	    return cb;
	}
	return new QDesignerCheckBox( parent, name );
    } else if ( className == "TQRadioButton" ) {
	if ( init ) {
	    QDesignerRadioButton *rb = new QDesignerRadioButton( parent, name );
	    rb->setText( TQString::fromLatin1( name ) );
	    return rb;
	}
	return new QDesignerRadioButton( parent, name );
    } else if ( className == "TQGroupBox" ) {
	if ( init )
	    return new TQGroupBox( TQString::fromLatin1( name ), parent, name );
	return new TQGroupBox( parent, name );
    } else if ( className == "TQButtonGroup" ) {
	if ( init )
	    return new TQButtonGroup( TQString::fromLatin1( name ), parent, name );
	return new TQButtonGroup( parent, name );
    } else if ( className == "TQIconView" ) {
#if !defined(TQT_NO_ICONVIEW)
	TQIconView* iv = new TQIconView( parent, name );
	if ( init )
	    (void) new TQIconViewItem( iv, i18n( "New Item" ) );
	return iv;
#else
	return 0;
#endif
    } else if ( className == "TQTable" ) {
#if !defined(TQT_NO_TABLE)
	if ( init )
	    return new TQTable( 3, 3, parent, name );
	return new TQTable( parent, name );
#else
	return 0;
#endif
#ifndef TQT_NO_SQL
    } else if ( className == "TQDataTable" ) {
	return new TQDataTable( parent, name );
#endif //TQT_NO_SQL
    } else if ( className == "TQDateEdit" ) {
	return new TQDateEdit( parent, name );
    } else if ( className == "TQTimeEdit" ) {
	return new TQTimeEdit( parent, name );
    } else if ( className == "TQDateTimeEdit" ) {
	return new TQDateTimeEdit( parent, name );
    }
    else if ( className == "TQListBox" ) {
	TQListBox* lb = new TQListBox( parent, name );
	if ( init ) {
	    lb->insertItem( i18n( "New Item" ) );
	    lb->setCurrentItem( 0 );
	}
	return lb;
    } else if ( className == "TQListView" ) {
	TQListView *lv = new TQListView( parent, name );
	lv->setSorting( -1 );
	if ( init ) {
	    lv->addColumn( i18n( "Column 1" ) );
	    lv->setCurrentItem( new TQListViewItem( lv, i18n( "New Item" ) ) );
	}
	return lv;
    } else if ( className == "TQLineEdit" )
	return new TQLineEdit( parent, name );
    else if ( className == "TQSpinBox" )
	return new TQSpinBox( parent, name );
    else if ( className == "TQSplitter" )
	return new TQSplitter( parent, name );
    else if ( className == "TQMultiLineEdit" )
	return new TQMultiLineEdit( parent, name );
    else if ( className == "TQTextEdit" )
	return new TQTextEdit( parent, name );
    else if ( className == "TQLabel"  || className == "TextLabel" ) {
	QDesignerLabel *l = new QDesignerLabel( parent, name );
	if ( init ) {
	    l->setText( TQString::fromLatin1( name ) );
	    MetaDataBase::addEntry( l );
	    MetaDataBase::setPropertyChanged( l, "text", TRUE );
	}
	return l;
    } else if ( className == "PixmapLabel" ) {
	QDesignerLabel *l = new QDesignerLabel( parent, name );
	if ( init ) {
	    l->setPixmap( BarIcon( "designer_qtlogo.png", KDevDesignerPartFactory::instance() ) );
	    l->setScaledContents( TRUE );
	    MetaDataBase::addEntry( l );
	    MetaDataBase::setPropertyChanged( l, "pixmap", TRUE );
	    MetaDataBase::setPropertyChanged( l, "scaledContents", TRUE );
	}
	return l;
    } else if ( className == "TQLayoutWidget" )
	return new TQLayoutWidget( parent, name );
    else if ( className == "TQTabWidget" ) {
	TQTabWidget *tw = new QDesignerTabWidget( parent, name );
	if ( init ) {
	    FormWindow *fw = find_formwindow( parent );
	    TQWidget *w = fw ? new QDesignerWidget( fw, tw, "tab" ) : new TQWidget( tw, "tab" );
	    tw->addTab( w, i18n("Tab 1") );
	    MetaDataBase::addEntry( w );
	    w = fw ? new QDesignerWidget( fw, tw, "tab" ) : new TQWidget( tw, "tab" );
	    tw->addTab( w, i18n("Tab 2") );
	    MetaDataBase::addEntry( tw );
	    MetaDataBase::addEntry( w );
	}
	return tw;
    } else if ( className == "TQWidgetStack" ) {
	QDesignerWidgetStack *ws = new QDesignerWidgetStack( parent, name );
	if ( init ) {
	    FormWindow *fw = find_formwindow( parent );
	    TQWidget *w = fw ? new QDesignerWidget( fw, ws, "WStackPage" ) : new TQWidget( ws, "WStackPage" );
	    ws->insertPage( w );
	    MetaDataBase::addEntry( w );
	    MetaDataBase::addEntry( ws );
	}
	return ws;
    } else if ( className == "TQComboBox" ) {
	return new TQComboBox( FALSE, parent, name );
    } else if ( className == "TQWidget" ) {
	if ( parent &&
	     ( ::tqt_cast<FormWindow*>(parent) ||
	       ::tqt_cast<TQWizard*>(parent) ||
	       ::tqt_cast<TQTabWidget*>(parent) ||
	       ::tqt_cast<TQWidgetStack*>(parent) ||
	       ::tqt_cast<TQToolBox*>(parent) ||
	       ::tqt_cast<TQMainWindow*>(parent) ) ) {
	    FormWindow *fw = find_formwindow( parent );
	    if ( fw ) {
		QDesignerWidget *dw = new QDesignerWidget( fw, parent, name );
		MetaDataBase::addEntry( dw );
		return dw;
	    }
	}
	return new TQWidget( parent, name );
    } else if ( className == "TQDialog" ) {
	TQDialog *dia = 0;
	if ( ::tqt_cast<FormWindow*>(parent) )
	    dia = new QDesignerDialog( (FormWindow*)parent, parent, name );
	else
	    dia = new TQDialog( parent, name );
	if ( parent )
	    dia->reparent( parent, TQPoint( 0, 0 ), TRUE );
	return dia;
    } else if ( className == "TQWizard" ) {
	TQWizard *wiz = new QDesignerWizard( parent, name );
	if ( parent )
	    wiz->reparent( parent, TQPoint( 0, 0 ), TRUE );
	if ( init && ::tqt_cast<FormWindow*>(parent) ) {
	    QDesignerWidget *dw = new QDesignerWidget( (FormWindow*)parent, wiz, "WizardPage" );
	    MetaDataBase::addEntry( dw );
	    wiz->addPage( dw, i18n( "Page" ) );
	    TQTimer::singleShot( 0, wiz, TQ_SLOT( next() ) );
	}
	return wiz;
    } else if ( className == "Spacer" ) {
	Spacer *s = new Spacer( parent, name );
	MetaDataBase::addEntry( s );
	MetaDataBase::setPropertyChanged( s, "orientation", TRUE );
	MetaDataBase::setPropertyChanged( s, "sizeType", TRUE );
	if ( !r )
	    return s;
	if ( !r->isValid() || r->width() < 2 && r->height() < 2 )
	    s->setOrientation( orient );
	else if ( r->width() < r->height() )
	    s->setOrientation( TQt::Vertical );
	else
	    s->setOrientation( TQt::Horizontal );
	return s;
    } else if ( className == "TQLCDNumber" )
	return new TQLCDNumber( parent, name );
    else if ( className == "TQProgressBar" )
	return new TQProgressBar( parent, name );
    else if ( className == "TQTextView" )
	return new TQTextView( parent, name );
    else if ( className == "TQTextBrowser" )
	return new TQTextBrowser( parent, name );
    else if ( className == "TQDial" )
	return new TQDial( parent, name );
    else if ( className == "TQSlider" ) {
	TQSlider *s = new TQSlider( parent, name );
	if ( !r )
	    return s;
	if ( !r->isValid() || r->width() < 2 && r->height() < 2 )
	    s->setOrientation( orient );
	else if ( r->width() > r->height() )
	    s->setOrientation( TQt::Horizontal );
	MetaDataBase::addEntry( s );
	MetaDataBase::setPropertyChanged( s, "orientation", TRUE );
	return s;
    } else if ( className == "TQScrollBar" ) {
	TQScrollBar *s = new TQScrollBar( parent, name );
	if ( !r )
	    return s;
	if ( !r->isValid() || r->width() < 2 && r->height() < 2 )
	    s->setOrientation( orient );
	else if ( r->width() > r->height() )
	    s->setOrientation( TQt::Horizontal );
	MetaDataBase::addEntry( s );
	MetaDataBase::setPropertyChanged( s, "orientation", TRUE );
	return s;
    } else if ( className == "TQFrame" ) {
	if ( !init )
	    return new TQFrame( parent, name );
	TQFrame *f = new TQFrame( parent, name );
	f->setFrameStyle( TQFrame::StyledPanel | TQFrame::Raised );
	return f;
    } else if ( className == "Line" ) {
	Line *l = new Line( parent, name );
	MetaDataBase::addEntry( l );
	MetaDataBase::setPropertyChanged( l, "orientation", TRUE );
	MetaDataBase::setPropertyChanged( l, "frameShadow", TRUE );
	MetaDataBase::setPropertyChanged( l, "frameShape", TRUE );
	if ( !r )
	    return l;
	if ( !r->isValid() || r->width() < 2 && r->height() < 2 )
	    l->setOrientation( orient );
	else if ( r->width() < r->height() )
	    l->setOrientation( TQt::Vertical );
	return l;
    } else if ( className == "TQMainWindow" ) {
	TQMainWindow *mw = new TQMainWindow( parent, name, 0 );
	mw->setDockEnabled( TQt::DockMinimized, FALSE );
	QDesignerWidget *dw = new QDesignerWidget( (FormWindow*)parent, mw, "central widget" );
	mw->setDockMenuEnabled( FALSE );
	MetaDataBase::addEntry( dw );
	mw->setCentralWidget( dw );
	(void)mw->statusBar();
	dw->show();
	return mw;
    } else if ( className == "TQToolBox" ) {
	if ( !init )
	    return new QDesignerToolBox( parent, name );
	TQToolBox *tb = new QDesignerToolBox( parent, name );
	FormWindow *fw = find_formwindow( parent );
	TQWidget *w = fw ? new QDesignerWidget( fw, tb, "page1" ) :
		     new TQWidget( tb, "page1" );
	tb->addItem( w, i18n("Page 1") );
	MetaDataBase::addEntry( w );
	w = fw ? new QDesignerWidget( fw, tb, "page2" ) : new TQWidget( tb, "page2" );
	tb->addItem( w, i18n("Page 2") );
	MetaDataBase::addEntry( tb );
	MetaDataBase::addEntry( w );
	return tb;
    }
#ifndef TQT_NO_SQL
    else if ( className == "TQDataBrowser" ) {
	TQWidget *w = new QDesignerDataBrowser( parent, name );
	if ( parent )
	    w->reparent( parent, TQPoint( 0, 0 ), TRUE );
	return w;
    } else if ( className == "TQDataView" ) {
	TQWidget *w = new QDesignerDataView( parent, name );
	if ( parent )
	    w->reparent( parent, TQPoint( 0, 0 ), TRUE );
	return w;
    }
#endif

    WidgetInterface *iface = 0;
    widgetManager()->queryInterface( className, &iface );
    if ( !iface )
	return 0;

    TQWidget *w = iface->create( className, parent, name );
#ifdef TQT_CONTAINER_CUSTOM_WIDGETS
    if ( init && WidgetDatabase::isCustomPluginWidget( WidgetDatabase::idFromClassName( className ) ) ) {
	TQWidgetContainerInterfacePrivate *iface2 = 0;
	iface->queryInterface( IID_TQWidgetContainer, (TQUnknownInterface**)&iface2 );
	if ( iface2 ) {
	    iface2->addPage( className, w, "Page", -1 );
	    iface2->release();
	}
    }
#endif // TQT_CONTAINER_CUSTOM_WIDGETS
    iface->release();
    return w;
}



/*!  Find out which type the layout of the widget is. Returns \c HBox,
  \c VBox, \c Grid or \c NoLayout.  \a layout points to this
  TQWidget::layout() of \a w or to 0 after the function call.
*/

WidgetFactory::LayoutType WidgetFactory::layoutType( TQWidget *w, TQLayout *&layout )
{
    layout = 0;

    if ( ::tqt_cast<TQTabWidget*>(w) )
	w = ((TQTabWidget*)w)->currentPage();
    if ( ::tqt_cast<TQWizard*>(w) )
	w = ((TQWizard*)w)->currentPage();
    if ( ::tqt_cast<TQMainWindow*>(w) )
	w = ((TQMainWindow*)w)->centralWidget();
    if ( ::tqt_cast<TQWidgetStack*>(w) )
	w = ((TQWidgetStack*)w)->visibleWidget();
    if ( ::tqt_cast<TQToolBox*>(w) )
	w = ((TQToolBox*)w)->currentItem();

    if ( ::tqt_cast<TQSplitter*>(w) )
	return ( (TQSplitter*)w )->orientation() ==TQt::Horizontal ? HBox : VBox;

    if ( !w || !w->layout() )
	return NoLayout;
    TQLayout *lay = w->layout();

    if ( ::tqt_cast<TQGroupBox*>(w) ) {
	TQObjectList *l = lay->queryList( "TQLayout" );
	if ( l && l->first() )
	    lay = (TQLayout*)l->first();
	delete l;
    }
    layout = lay;

    if ( ::tqt_cast<TQHBoxLayout*>(lay) )
	return HBox;
    else if ( ::tqt_cast<TQVBoxLayout*>(lay) )
	return VBox;
    else if ( ::tqt_cast<TQGridLayout*>(lay) )
	return Grid;
    return NoLayout;
}

/*!
  \overload
*/
WidgetFactory::LayoutType WidgetFactory::layoutType( TQLayout *layout )
{
    if ( ::tqt_cast<TQHBoxLayout*>(layout) )
	return HBox;
    else if ( ::tqt_cast<TQVBoxLayout*>(layout) )
	return VBox;
    else if ( ::tqt_cast<TQGridLayout*>(layout) )
	return Grid;
    return NoLayout;
}

/*!
  \overload
*/
WidgetFactory::LayoutType WidgetFactory::layoutType( TQWidget *w )
{
    TQLayout *l = 0;
    return layoutType( w, l );
}


TQWidget *WidgetFactory::layoutParent( TQLayout *layout )
{
    TQObject *o = layout;
    while ( o ) {
	if ( o->isWidgetType() )
	    return (TQWidget*)o;
	o = o->parent();
    }
    return 0;
}

/*!  Returns the widget into which children should be inserted when \a
  w is a container known to the designer.

  Usually that is \a w itself, sometimes it is different (e.g. a
  tabwidget is known to the designer as a container but the child
  widgets should be inserted into the current page of the
  tabwidget. So in this case this function returns the current page of
  the tabwidget.)
 */
TQWidget* WidgetFactory::containerOfWidget( TQWidget *w )
{
    if ( !w )
	return w;
    if ( ::tqt_cast<TQTabWidget*>(w) )
	return ((TQTabWidget*)w)->currentPage();
    if ( ::tqt_cast<TQWizard*>(w) )
	return ((TQWizard*)w)->currentPage();
    if ( ::tqt_cast<TQWidgetStack*>(w) )
	return ((TQWidgetStack*)w)->visibleWidget();
    if ( ::tqt_cast<TQToolBox*>(w) )
	return ((TQToolBox*)w)->currentItem();
    if ( ::tqt_cast<TQMainWindow*>(w) )
	return ((TQMainWindow*)w)->centralWidget();
#ifdef TQT_CONTAINER_CUSTOM_WIDGETS
    if ( !WidgetDatabase::isCustomPluginWidget( WidgetDatabase::idFromClassName( classNameOf( w ) ) ) )
	return w;
    WidgetInterface *iface = 0;
    widgetManager()->queryInterface( classNameOf( w ), &iface );
    if ( !iface )
	return w;
    TQWidgetContainerInterfacePrivate *iface2 = 0;
    iface->queryInterface( IID_TQWidgetContainer, (TQUnknownInterface**)&iface2 );
    if ( !iface2 )
	return w;
    TQWidget *c = iface2->containerOfWidget( w->className(), w );
    iface2->release();
    iface->release();
    if ( c )
	return c;
#endif // TQT_CONTAINER_CUSTOM_WIDGETS
    return w;
}

/*!  Returns the actual designer widget of the container \a w. This is
  normally \a w itself, but might be a parent or grand parent of \a w
  (e.g. when working with a tabwidget and \a w is the container which
  contains and layouts childs, but the actual widget known to the
  designer is the tabwidget which is the parent of \a w. So this
  function returns the tabwidget then.)
*/

TQWidget* WidgetFactory::widgetOfContainer( TQWidget *w )
{
    if ( w && ::tqt_cast<TQWidgetStack*>(w->parentWidget()) )
	w = w->parentWidget();
    if ( w->parentWidget() && w->parentWidget()->parentWidget() &&
	 w->parentWidget()->parentWidget()->parentWidget() &&
	 ::tqt_cast<TQToolBox*>(w->parentWidget()->parentWidget()->parentWidget()) )
	return w->parentWidget()->parentWidget()->parentWidget();
    while ( w ) {
	int id = WidgetDatabase::idFromClassName( WidgetFactory::classNameOf( w ) );
	if ( WidgetDatabase::isContainer( id ) ||
	     w && ::tqt_cast<FormWindow*>(w->parentWidget()) )
	    return w;
	w = w->parentWidget();
    }
    return w;
}

/*!
  Returns whether \a o is a passive interactor or not.
 */

bool WidgetFactory::lastWasAPassiveInteractor = FALSE;
TQGuardedPtr<TQObject> *WidgetFactory::lastPassiveInteractor = new TQGuardedPtr<TQObject>();

bool WidgetFactory::isPassiveInteractor( TQObject* o )
{
    if ( lastPassiveInteractor && *lastPassiveInteractor && (TQObject*)(*lastPassiveInteractor) == o )
	return lastWasAPassiveInteractor;
    lastWasAPassiveInteractor = FALSE;
    (*lastPassiveInteractor) = o;
    if ( TQApplication::activePopupWidget() ) // if a popup is open, we have to make sure that this one is closed, else X might do funny things
	return ( lastWasAPassiveInteractor = TRUE );

    if ( ::tqt_cast<TQTabBar*>(o) )
	return ( lastWasAPassiveInteractor = TRUE );
    else if ( ::tqt_cast<TQSizeGrip*>(o) )
	return ( lastWasAPassiveInteractor = TRUE );
    else if ( ::tqt_cast<TQButton*>(o) &&
	      ( ::tqt_cast<TQTabBar*>(o->parent()) || ::tqt_cast<TQToolBox*>(o->parent()) ) )
	return ( lastWasAPassiveInteractor = TRUE );
    else if ( ::tqt_cast<TQPushButton*>(o) && ::tqt_cast<TQWizard*>(o->parent()) )
	return ( lastWasAPassiveInteractor = TRUE );
    else if ( ::tqt_cast<TQMenuBar*>(o) && ::tqt_cast<TQMainWindow*>(o->parent()) )
	return ( lastWasAPassiveInteractor = TRUE );
//    else if ( ::tqt_cast<TQDockWindowHandle*>(o) )
    else if ( o->inherits( "TQDockWindowHandle" ) )
	return ( lastWasAPassiveInteractor = TRUE );
//    else if ( ::tqt_cast<TQHideDock*>(o) )
    else if ( o->inherits( "TQHideDock" ) )
	return ( lastWasAPassiveInteractor = TRUE );
    else if ( qstrcmp( o->name(), "designer_wizardstack_button" ) == 0 )
	return ( lastWasAPassiveInteractor = TRUE );
#ifdef TQT_CONTAINER_CUSTOM_WIDGETS
    if ( !o->isWidgetType() )
	return ( lastWasAPassiveInteractor = FALSE );
    WidgetInterface *iface = 0;
    TQWidget *w = (TQWidget*)o;
    while ( !iface && w && !::tqt_cast<FormWindow*>(w) ) {
	widgetManager()->queryInterface( classNameOf( w ), &iface );
	w = w->parentWidget();
    }
    if ( !iface )
	return ( lastWasAPassiveInteractor = FALSE );
    TQWidgetContainerInterfacePrivate *iface2 = 0;
    iface->queryInterface( IID_TQWidgetContainer, (TQUnknownInterface**)&iface2 );
    if ( !iface2 )
	return ( lastWasAPassiveInteractor = FALSE );
    TQWidget *fw = MainWindow::self->isAFormWindowChild( (TQWidget*)o );
    if ( !fw )
	return ( lastWasAPassiveInteractor = FALSE );
    TQWidget *dw = ( (FormWindow*)fw )->designerWidget( (TQWidget*)o );
    if ( !dw )
	return ( lastWasAPassiveInteractor = FALSE );
    lastWasAPassiveInteractor = iface2->isPassiveInteractor( dw->className(), (TQWidget*)o );
    iface2->release();
    iface->release();
#endif // TQT_CONTAINER_CUSTOM_WIDGETS
    return lastWasAPassiveInteractor;
}


/*!
  Returns the class name of object \a o that should be used for externally (i.e. for saving)
 */
const char* WidgetFactory::classNameOf( TQObject* o )
{
    if ( o->isA( "PropertyObject" ) )
	return o->className();
    if (WidgetDatabase::isCustomPluginWidget(WidgetDatabase::idFromClassName(o->className())))
        return o->className();
    else if ( ::tqt_cast<QDesignerTabWidget*>(o) )
	return "TQTabWidget";
    else if ( ::tqt_cast<QDesignerWidgetStack*>(o) )
	return "TQWidgetStack";
    else if ( ::tqt_cast<TQWidgetStack*>(o) )
	return "TQWeDoNotWantToBreakTabWidget";
    else if ( ::tqt_cast<QDesignerDialog*>(o) )
	return "TQDialog";
    else if ( ::tqt_cast<QDesignerWidget*>(o) )
	return "TQWidget";
    else if ( o->inherits( "CustomWidget" ) )
	return ( (CustomWidget*)o )->realClassName().latin1();
    else if ( ::tqt_cast<QDesignerLabel*>(o) )
	return "TQLabel";
    else if ( ::tqt_cast<QDesignerWizard*>(o) )
	return "TQWizard";
    else if ( ::tqt_cast<QDesignerPushButton*>(o) )
	return "TQPushButton";
    else if ( ::tqt_cast<QDesignerToolButton*>(o) )
	return "TQToolButton";
    else if ( ::tqt_cast<QDesignerRadioButton*>(o) )
	return "TQRadioButton";
    else if ( ::tqt_cast<QDesignerCheckBox*>(o) )
	return "TQCheckBox";
    else if ( ::tqt_cast<MenuBarEditor*>(o) )
	return "TQMenuBar";
    else if ( ::tqt_cast<QDesignerToolBar*>(o) )
	return "TQToolBar";
    else if ( ::tqt_cast<QDesignerAction*>(o) )
	return "TQAction";
    else if ( ::tqt_cast<QDesignerActionGroup*>(o) )
	return "TQActionGroup";
    else if ( ::tqt_cast<PopupMenuEditor*>(o) )
	return "TQPopupMenu";
    else if ( ::tqt_cast<QDesignerToolBox*>(o) )
	return "TQToolBox";
#ifndef TQT_NO_SQL
    else if ( ::tqt_cast<QDesignerDataBrowser*>(o) )
	return "TQDataBrowser";
    else if ( ::tqt_cast<QDesignerDataView*>(o) )
	return "TQDataView";
#endif
    return o->className();
}

TQString WidgetFactory::defaultSignal( TQObject *w )
{
    if ( ::tqt_cast<TQRadioButton*>(w) || ::tqt_cast<TQCheckBox*>(w) )
	return "toggled";
    else if ( ::tqt_cast<TQButton*>(w) || ::tqt_cast<TQButtonGroup*>(w) )
	return "clicked";
    else if ( ::tqt_cast<TQTextBrowser*>(w) )
	return "linkClicked";
    else if ( ::tqt_cast<TQLineEdit*>(w) || ::tqt_cast<TQTextEdit*>(w) )
	return "textChanged";
    else if ( ::tqt_cast<TQListView*>(w) || ::tqt_cast<TQIconView*>(w) ||
	      ::tqt_cast<TQListBox*>(w) || ::tqt_cast<TQTable*>(w) )
	return "selectionChanged";
    else if ( ::tqt_cast<TQTabWidget*>(w) )
	return "selected";
    else if ( ::tqt_cast<TQToolBox*>(w) )
	return "currentChanged";
    else if ( ::tqt_cast<TQWidgetStack*>(w) )
	return "aboutToShow";
    else if ( ::tqt_cast<TQSpinBox*>(w) || ::tqt_cast<TQSlider*>(w) ||
	      ::tqt_cast<TQScrollBar*>(w) || ::tqt_cast<TQDateEdit*>(w) ||
	      ::tqt_cast<TQTimeEdit*>(w) || ::tqt_cast<TQDateTimeEdit*>(w) ||
	      ::tqt_cast<TQDial*>(w) )
	return "valueChanged";
    else if ( ::tqt_cast<TQComboBox*>(w) )
	return "activated";
    return TQString();
}

/*!  As some properties are set by default when creating a widget this
  functions markes this properties as changed. Has to be in sync with
  createWidget()!
*/

void WidgetFactory::initChangedProperties( TQObject *o )
{
    if ( MainWindow::self && MainWindow::self->currProject() &&
	 MainWindow::self->currProject()->fakeFormFileFor( o ) )
	return;
    MetaDataBase::setPropertyChanged( o, "name", TRUE );
    if ( !::tqt_cast<QDesignerToolBar*>(o) && !::tqt_cast<MenuBarEditor*>(o) )
	MetaDataBase::setPropertyChanged( o, "geometry", TRUE );

    if ( ::tqt_cast<TQPushButton*>(o) ||
	 ::tqt_cast<TQRadioButton*>(o) ||
	 ::tqt_cast<TQCheckBox*>(o) ||
	 ::tqt_cast<TQToolButton*>(o) ) {
	if (::tqt_cast<TQToolButton*>(o) && ::tqt_cast<TQToolBox*>(widgetOfContainer((TQWidget*)o->parent()))) {
	    MetaDataBase::setPropertyChanged( o, "usesTextLabel", TRUE );
	    MetaDataBase::setPropertyChanged( o, "textLabel", TRUE );
	    MetaDataBase::setPropertyChanged( o, "autoRaise", TRUE );
	    MetaDataBase::setPropertyChanged( o, "textPosition", TRUE );
	} else {
	    MetaDataBase::setPropertyChanged( o, "text", TRUE );
	}
    }
    else if ( ::tqt_cast<TQGroupBox*>(o) )
	MetaDataBase::setPropertyChanged( o, "title", TRUE );
    else if ( o->isA( "TQFrame" ) ) {
	MetaDataBase::setPropertyChanged( o, "frameShadow", TRUE );
	MetaDataBase::setPropertyChanged( o, "frameShape", TRUE );
    } else if ( ::tqt_cast<TQTabWidget*>(o) || ::tqt_cast<TQWizard*>(o) ) {
	MetaDataBase::setPropertyChanged( o, "pageTitle", TRUE );
	MetaDataBase::setPropertyChanged( o, "pageName", TRUE );
	MetaDataBase::setPropertyChanged( o, "currentPage", TRUE );
    } else if ( ::tqt_cast<TQWidgetStack*>(o) ) {
	MetaDataBase::setPropertyChanged( o, "currentPage", TRUE );
	MetaDataBase::setPropertyChanged( o, "pageName", TRUE );
    } else if ( ::tqt_cast<TQToolBox*>(o) ) {
	MetaDataBase::setPropertyChanged( o, "currentIndex", TRUE );
	MetaDataBase::setPropertyChanged( o, "itemName", TRUE );
	MetaDataBase::setPropertyChanged( o, "itemLabel", TRUE );
	MetaDataBase::setPropertyChanged( o, "itemIconSet", TRUE );
	MetaDataBase::setPropertyChanged( o, "itemToolTip", TRUE );
	MetaDataBase::setPropertyChanged( o, "itemBackgroundMode", TRUE );
#ifndef TQT_NO_TABLE
    } else if ( ::tqt_cast<TQTable*>(o) ) {
#  ifndef TQT_NO_SQL
        if (!::tqt_cast<TQDataTable*>(o) )
#  endif
        {
            MetaDataBase::setPropertyChanged( o, "numRows", TRUE );
            MetaDataBase::setPropertyChanged( o, "numCols", TRUE );
            TQTable *t = (TQTable*)o;
            for ( int i = 0; i < 3; ++i ) {
                t->horizontalHeader()->setLabel( i, TQString::number( i + 1 ) );
                t->verticalHeader()->setLabel( i, TQString::number( i + 1 ) );
            }
        }
#endif
    } else if ( ::tqt_cast<TQSplitter*>(o)  ) {
	MetaDataBase::setPropertyChanged( o, "orientation", TRUE );
    } else if ( ::tqt_cast<QDesignerToolBar*>(o)  ) {
	MetaDataBase::setPropertyChanged( o, "label", TRUE );
    } else if ( ::tqt_cast<MenuBarEditor*>(o)  ) {
	MetaDataBase::setPropertyChanged( o, "itemName", TRUE );
	MetaDataBase::setPropertyChanged( o, "itemNumber", TRUE );
	MetaDataBase::setPropertyChanged( o, "itemText", TRUE );
    }
}

bool WidgetFactory::hasSpecialEditor( int id, TQObject *editorWidget )
{
    TQString className = WidgetDatabase::className( id );

    if ( className.contains( "ListBox" ) )
	return TRUE;
    if ( className.contains( "ComboBox" ) )
	return TRUE;
    if ( className.contains( "ListView" ) )
	return TRUE;
    if ( className.contains( "IconView" ) )
	return TRUE;
    if ( className == "TQTextEdit" || className == "TQMultiLineEdit" )
	return TRUE;
    if ( ::tqt_cast<TQTable*>(editorWidget) != 0 )
	return TRUE;

    return FALSE;
}

bool WidgetFactory::hasItems( int id, TQObject *editorWidget )
{
    TQString className = WidgetDatabase::className( id );

    if ( className.contains( "ListBox" ) || className.contains( "ListView" ) ||
	 className.contains( "IconView" )  || className.contains( "ComboBox" ) ||
	 ::tqt_cast<TQTable*>(editorWidget) != 0 )
	return TRUE;

    return FALSE;
}

void WidgetFactory::editWidget( int id, TQWidget *parent, TQWidget *editWidget, FormWindow *fw )
{
    TQString className = WidgetDatabase::className( id );

    if ( className.contains( "ListBox" ) ) {
	if ( !::tqt_cast<TQListBox*>(editWidget) )
	    return;
	ListBoxEditor *e = new ListBoxEditor( parent, editWidget, fw );
	e->exec();
	delete e;
	return;
    }

    if ( className.contains( "ComboBox" ) ) {
	if ( !::tqt_cast<TQComboBox*>(editWidget) )
	    return;
	TQComboBox *cb = (TQComboBox*)editWidget;
	ListBoxEditor *e = new ListBoxEditor( parent, cb->listBox(), fw );
	e->exec();
	delete e;
	cb->update();
	return;
    }

    if ( className.contains( "ListView" ) ) {
	if ( !::tqt_cast<TQListView*>(editWidget) )
	    return;
	TQListView *lv = (TQListView*)editWidget;
	ListViewEditor *e = new ListViewEditor( parent, lv, fw );
	e->exec();
	delete e;
	return;
    }

    if ( className.contains( "IconView" ) ) {
	if ( !::tqt_cast<TQIconView*>(editWidget) )
	    return;
	IconViewEditor *e = new IconViewEditor( parent, editWidget, fw );
	e->exec();
	delete e;
	return;
    }

    if ( className == "TQMultiLineEdit" || className == "TQTextEdit" ) {
	MultiLineEditor *e = new MultiLineEditor( FALSE, TRUE, parent, editWidget, fw );
	e->exec();
	delete e;
	return;
    }
#ifndef TQT_NO_TABLE
    if (::tqt_cast<TQTable*>(editWidget) != 0) {
	TableEditor *e = new TableEditor( parent, editWidget, fw );
	e->exec();
	delete e;
	return;
    }
#endif
}

bool WidgetFactory::canResetProperty( TQObject *w, const TQString &propName )
{
    if ( propName == "name" || propName == "geometry" )
	return FALSE;
    TQStringList l = *changedProperties->find( WidgetDatabase::idFromClassName( WidgetFactory::classNameOf( w ) ) );
    return l.findIndex( propName ) == -1;
}

bool WidgetFactory::resetProperty( TQObject *w, const TQString &propName )
{
    const TQMetaProperty *p = w->metaObject()->property( w->metaObject()->
							findProperty( propName, TRUE ), TRUE );
    if (!p )
	return FALSE;
    return p->reset( w );
}

TQVariant WidgetFactory::defaultValue( TQObject *w, const TQString &propName )
{
    if ( propName == "wordwrap" ) {
	int v = defaultValue( w, "alignment" ).toInt();
	return TQVariant( ( v & WordBreak ) == WordBreak );
    } else if ( propName == "toolTip" || propName == "whatsThis" ) {
	return TQVariant( TQString::fromLatin1( "" ) );
    } else if ( w->inherits( "CustomWidget" ) ) {
	return TQVariant();
    } else if ( propName == "frameworkCode" ) {
	return TQVariant( true );
    } else if ( propName == "layoutMargin" || propName == "layoutSpacing" ) {
	return TQVariant( -1 );
    }

    return *( *defaultProperties->find( WidgetDatabase::idFromClassName( classNameOf( w ) ) ) ).find( propName );
}

TQString WidgetFactory::defaultCurrentItem( TQObject *w, const TQString &propName )
{
    const TQMetaProperty *p = w->metaObject()->
			     property( w->metaObject()->findProperty( propName, TRUE ), TRUE );
    if ( !p ) {
	int v = defaultValue( w, "alignment" ).toInt();
	if ( propName == "hAlign" ) {
	    if ( ( v & AlignAuto ) == AlignAuto )
		return "AlignAuto";
	    if ( ( v & AlignLeft ) == AlignLeft )
		return "AlignLeft";
	    if ( ( v & AlignCenter ) == AlignCenter || ( v & AlignHCenter ) == AlignHCenter )
		return "AlignHCenter";
	    if ( ( v & AlignRight ) == AlignRight )
		return "AlignRight";
	    if ( ( v & AlignJustify ) == AlignJustify )
		return "AlignJustify";
	} else if ( propName == "vAlign" ) {
	    if ( ( v & AlignTop ) == AlignTop )
		return "AlignTop";
	    if ( ( v & AlignCenter ) == AlignCenter || ( v & AlignVCenter ) == AlignVCenter )
		return "AlignVCenter";
	    if ( ( v & AlignBottom ) == AlignBottom )
		return "AlignBottom";
	} else if ( propName == "resizeMode" ) {
	    return "Auto";
	}
	return TQString();

    }
    return p->valueToKey( defaultValue( w, propName ).toInt() );
}

TQWidget *WidgetFactory::createCustomWidget( TQWidget *parent, const char *name, MetaDataBase::CustomWidget *w )
{
    if ( !w )
	return 0;
    return new CustomWidget( parent, name, w );
}

TQVariant WidgetFactory::property( TQObject *w, const char *name )
{
    int id = w->metaObject()->findProperty( name, TRUE );
    const TQMetaProperty* p = w->metaObject()->property( id, TRUE );
    if ( !p || !p->isValid() )
	return MetaDataBase::fakeProperty( w, name );
    return w->property( name );
}

void QDesignerLabel::updateBuddy()
{

    if ( myBuddy.isEmpty() )
	return;

    TQObjectList *l = topLevelWidget()->queryList( "TQWidget", myBuddy, FALSE, TRUE );
    if ( !l || !l->first() ) {
	delete l;
	return;
    }

    TQLabel::setBuddy( (TQWidget*)l->first() );
    delete l;
}


void QDesignerWidget::resizeEvent( TQResizeEvent* e)
{
    if ( need_frame ) {
	TQPainter p(this);
	p.setPen( backgroundColor() );
	p.drawRect( TQRect( TQPoint(0,0), e->oldSize() ) );
    }
}

void QDesignerWidget::paintEvent( TQPaintEvent *e )
{
    if ( need_frame ) {
	TQPainter p(this);
	p.setPen( backgroundColor().dark() );
	p.drawRect( rect() );
    }
    formwindow->paintGrid( this, e );
}

void QDesignerDialog::paintEvent( TQPaintEvent *e )
{
    formwindow->paintGrid( this, e );
}

TQSizePolicy TQLayoutWidget::sizePolicy() const
{
    return sp;
}

bool TQLayoutWidget::event( TQEvent *e )
{
    if ( e && ( e->type() == TQEvent::ChildInserted ||
		e->type() == TQEvent::ChildRemoved ||
		e->type() == TQEvent::LayoutHint ||
		e->type() == TQEvent::Reparent ) )
	updateSizePolicy();
    return TQWidget::event( e );
}

/*
  This function must be called on TQLayoutWidget creation and whenever
  the TQLayoutWidget's parent layout changes (e.g., from a TQHBoxLayout
  to a TQVBoxLayout), because of the (illogical) way layouting works.
*/
void TQLayoutWidget::updateSizePolicy()
{
    if ( childrenListObject().isEmpty() || childrenListObject().count() == 0 ) {
	sp = TQWidget::sizePolicy();
	return;
    }

    /*
      TQSizePolicy::MayShrink & friends are private. Here we assume the
      following:

	  Fixed = 0
	  Maximum = MayShrink
	  Minimum = MayGrow
	  Preferred = MayShrink | MayGrow
    */

    int ht = (int) TQSizePolicy::Preferred;
    int vt = (int) TQSizePolicy::Preferred;

    if ( layout() ) {
	/*
	  parentLayout is set to the parent layout if there is one and if it is
	  top level, in which case layouting is illogical.
	*/
	TQLayout *parentLayout = 0;
	if ( parent() && parent()->isWidgetType() ) {
	    parentLayout = ((TQWidget *)parent())->layout();
	    if ( parentLayout &&
		 ::tqt_cast<TQLayoutWidget*>(parentLayout->mainWidget()) )
		parentLayout = 0;
	}

	TQObjectListIt it( childrenListObject() );
	TQObject *o;

	if ( ::tqt_cast<TQVBoxLayout*>(layout()) ) {
	    if ( ::tqt_cast<TQHBoxLayout*>(parentLayout) )
		vt = TQSizePolicy::Minimum;
	    else
		vt = TQSizePolicy::Fixed;

	    while ( ( o = it.current() ) ) {
		++it;
		if ( !o->isWidgetType() || ( (TQWidget*)o )->testWState( WState_ForceHide ) )
		    continue;
		TQWidget *w = (TQWidget*)o;

		if ( !w->sizePolicy().mayGrowHorizontally() )
		    ht &= ~TQSizePolicy::Minimum;
		if ( !w->sizePolicy().mayShrinkHorizontally() )
		    ht &= ~TQSizePolicy::Maximum;
		if ( w->sizePolicy().mayGrowVertically() )
		    vt |= TQSizePolicy::Minimum;
		if ( w->sizePolicy().mayShrinkVertically() )
		    vt |= TQSizePolicy::Maximum;
	    }
	} else if ( ::tqt_cast<TQHBoxLayout*>(layout()) ) {
	    if ( ::tqt_cast<TQVBoxLayout*>(parentLayout) )
		ht = TQSizePolicy::Minimum;
	    else
		ht = TQSizePolicy::Fixed;

	    while ( ( o = it.current() ) ) {
		++it;
		if ( !o->isWidgetType() || ( (TQWidget*)o )->testWState( WState_ForceHide ) )
		    continue;
		TQWidget *w = (TQWidget*)o;

		if ( w->sizePolicy().mayGrowHorizontally() )
		    ht |= TQSizePolicy::Minimum;
		if ( w->sizePolicy().mayShrinkHorizontally() )
		    ht |= TQSizePolicy::Maximum;
		if ( !w->sizePolicy().mayGrowVertically() )
		    vt &= ~TQSizePolicy::Minimum;
		if ( !w->sizePolicy().mayShrinkVertically() )
		    vt &= ~TQSizePolicy::Maximum;
	    }
	} else if ( ::tqt_cast<TQGridLayout*>(layout()) ) {
	    ht = TQSizePolicy::Fixed;
	    vt = TQSizePolicy::Fixed;
	    if ( parentLayout ) {
		if ( ::tqt_cast<TQVBoxLayout*>(parentLayout) )
		    ht = TQSizePolicy::Minimum;
		else if ( ::tqt_cast<TQHBoxLayout*>(parentLayout) )
		    vt = TQSizePolicy::Minimum;
	    }

	    while ( ( o = it.current() ) ) {
		++it;
		if ( !o->isWidgetType() || ( (TQWidget*)o )->testWState( WState_ForceHide ) )
		    continue;
		TQWidget *w = (TQWidget*)o;

		if ( w->sizePolicy().mayGrowHorizontally() )
		    ht |= TQSizePolicy::Minimum;
		if ( w->sizePolicy().mayShrinkHorizontally() )
		    ht |= TQSizePolicy::Maximum;
		if ( w->sizePolicy().mayGrowVertically() )
		    vt |= TQSizePolicy::Minimum;
		if ( w->sizePolicy().mayShrinkVertically() )
		    vt |= TQSizePolicy::Maximum;
	    }
	}
	if ( layout()->expanding() & TQSizePolicy::Horizontally )
	    ht = TQSizePolicy::Expanding;
	if ( layout()->expanding() & TQSizePolicy::Vertically )
	    vt = TQSizePolicy::Expanding;

	layout()->invalidate();
    }

    sp = TQSizePolicy( (TQSizePolicy::SizeType) ht, (TQSizePolicy::SizeType) vt );
    updateGeometry();
}

void CustomWidget::paintEvent( TQPaintEvent *e )
{
    if ( ::tqt_cast<FormWindow*>(parentWidget()) ) {
	( (FormWindow*)parentWidget() )->paintGrid( this, e );
    } else {
	TQPainter p( this );
	p.fillRect( rect(), colorGroup().dark() );
	p.setPen( colorGroup().light() );
	p.drawText( 2, 2, width() - 4, height() - 4, TQt::AlignAuto | TQt::AlignTop, cusw->className );
	p.drawPixmap( ( width() - cusw->pixmap->width() ) / 2,
		      ( height() - cusw->pixmap->height() ) / 2,
		      *cusw->pixmap );
    }
}


CustomWidgetFactory::CustomWidgetFactory()
{
}

TQWidget *CustomWidgetFactory::createWidget( const TQString &className, TQWidget *parent, const char *name ) const
{
    MetaDataBase::CustomWidget *w = MetaDataBase::customWidget( WidgetDatabase::idFromClassName( className ) );
    if ( !w )
	return 0;
    return WidgetFactory::createCustomWidget( parent, name, w );
}


QDesignerToolBox::QDesignerToolBox( TQWidget *parent, const char *name )
    : TQToolBox( parent, name )
{
}

TQString QDesignerToolBox::itemLabel() const
{
    return TQToolBox::itemLabel( currentIndex() );
}

void QDesignerToolBox::setItemLabel( const TQString &l )
{
    TQToolBox::setItemLabel( currentIndex(), l );
}

TQCString QDesignerToolBox::itemName() const
{
    return currentItem() ? currentItem()->name() : 0;
}

void QDesignerToolBox::setItemName( const TQCString &n )
{
    if (currentItem())
	currentItem()->setName( n );
}


TQt::BackgroundMode QDesignerToolBox::itemBackgroundMode() const
{
    return (item(0) ? item(0)->backgroundMode() : PaletteBackground);
}

void QDesignerToolBox::setItemBackgroundMode( BackgroundMode bmode )
{
    for (int i = 0; i < count(); ++i) {
	TQWidget *w = item(i);
	w->setBackgroundMode( bmode );
	w->update();
    }
}

void QDesignerToolBox::itemInserted( int index )
{
    if (count() > 1)
	item(index)->setBackgroundMode(item(index>0?0:1)->backgroundMode());
}