You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1806 lines
56 KiB
1806 lines
56 KiB
/**********************************************************************
|
|
** 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 <klocale.h>
|
|
|
|
FormWindow *find_formwindow( TQWidget *w )
|
|
{
|
|
if ( !w )
|
|
return 0;
|
|
for (;;) {
|
|
if ( ::tqqt_cast<FormWindow*>(w) )
|
|
return (FormWindow*)w;
|
|
if ( !w->tqparentWidget() )
|
|
return 0;
|
|
w = w->tqparentWidget();
|
|
}
|
|
}
|
|
|
|
void TQLayoutWidget::paintEvent( TQPaintEvent* )
|
|
{
|
|
TQPainter p ( this );
|
|
p.setPen( red );
|
|
p.drawRect( rect() );
|
|
}
|
|
|
|
|
|
TQDesignerTabWidget::TQDesignerTabWidget( TQWidget *tqparent, const char *name )
|
|
: TQTabWidget( tqparent, name ), dropIndicator( 0 ), dragPage( 0 ), mousePressed( FALSE )
|
|
{
|
|
tabBar()->setAcceptDrops( TRUE );
|
|
tabBar()->installEventFilter( this );
|
|
}
|
|
|
|
int TQDesignerTabWidget::currentPage() const
|
|
{
|
|
return tabBar()->currentTab();
|
|
}
|
|
|
|
void TQDesignerTabWidget::setCurrentPage( int i )
|
|
{
|
|
tabBar()->setCurrentTab( i );
|
|
}
|
|
|
|
TQString TQDesignerTabWidget::pageTitle() const
|
|
{
|
|
return ((TQTabWidget*)this)->tabLabel( TQTabWidget::currentPage() );
|
|
}
|
|
|
|
void TQDesignerTabWidget::setPageTitle( const TQString& title )
|
|
{
|
|
changeTab( TQTabWidget::currentPage(), title );
|
|
}
|
|
|
|
void TQDesignerTabWidget::setPageName( const TQCString& name )
|
|
{
|
|
if ( TQTabWidget::currentPage() )
|
|
TQTabWidget::currentPage()->setName( name );
|
|
}
|
|
|
|
TQCString TQDesignerTabWidget::pageName() const
|
|
{
|
|
if ( !TQTabWidget::currentPage() )
|
|
return 0;
|
|
return TQTabWidget::currentPage()->name();
|
|
}
|
|
|
|
int TQDesignerTabWidget::count() const
|
|
{
|
|
return tabBar()->count();
|
|
}
|
|
|
|
bool TQDesignerTabWidget::eventFilter( TQObject *o, TQEvent *e )
|
|
{
|
|
if ( TQT_BASE_OBJECT(o) != TQT_BASE_OBJECT(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().tqcontains( 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.tqcontains( 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().tqcontains( de->pos() ) )
|
|
break;
|
|
}
|
|
|
|
if ( newIndex == tabBar()->count() -1 ) {
|
|
TQRect rect2 = tabBar()->tabAt( newIndex )->rect();
|
|
rect2.setLeft( rect2.left() + rect2.width() / 2 );
|
|
if ( rect2.tqcontains( de->pos() ) )
|
|
newIndex++;
|
|
}
|
|
|
|
int oldIndex = 0;
|
|
for ( ; oldIndex < tabBar()->count(); oldIndex++ ) {
|
|
if ( tabBar()->tabAt( oldIndex )->rect().tqcontains( 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;
|
|
}
|
|
|
|
|
|
TQDesignerWidgetStack::TQDesignerWidgetStack( TQWidget *tqparent, const char *name )
|
|
: TQWidgetStack( tqparent, name )
|
|
{
|
|
prev = new TQToolButton( TQt::LeftArrow, this, "designer_wizardstack_button" );
|
|
prev->setAutoRaise( TRUE );
|
|
prev->setAutoRepeat( TRUE );
|
|
prev->tqsetSizePolicy( TQSizePolicy( TQSizePolicy::Ignored, TQSizePolicy::Ignored ) );
|
|
next = new TQToolButton( TQt::RightArrow, this, "designer_wizardstack_button" );
|
|
next->setAutoRaise( TRUE );
|
|
next->setAutoRepeat( TRUE );
|
|
next->tqsetSizePolicy( TQSizePolicy( TQSizePolicy::Ignored, TQSizePolicy::Ignored ) );
|
|
connect( prev, TQT_SIGNAL( clicked() ), this, TQT_SLOT( prevPage() ) );
|
|
connect( next, TQT_SIGNAL( clicked() ), this, TQT_SLOT( nextPage() ) );
|
|
updateButtons();
|
|
}
|
|
|
|
void TQDesignerWidgetStack::updateButtons()
|
|
{
|
|
prev->setGeometry( width() - 31, 1, 15, 15 );
|
|
next->setGeometry( width() - 16, 1, 15, 15 );
|
|
prev->show();
|
|
next->show();
|
|
prev->raise();
|
|
next->raise();
|
|
}
|
|
|
|
void TQDesignerWidgetStack::prevPage()
|
|
{
|
|
setCurrentPage( currentPage() - 1 );
|
|
}
|
|
|
|
void TQDesignerWidgetStack::nextPage()
|
|
{
|
|
setCurrentPage( currentPage() + 1 );
|
|
}
|
|
|
|
int TQDesignerWidgetStack::currentPage() const
|
|
{
|
|
TQDesignerWidgetStack* that = (TQDesignerWidgetStack*) this;
|
|
return that->pages.tqfind( visibleWidget() );
|
|
}
|
|
|
|
void TQDesignerWidgetStack::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 TQDesignerWidgetStack::pageName() const
|
|
{
|
|
if ( !visibleWidget() )
|
|
return 0;
|
|
return visibleWidget()->name();
|
|
}
|
|
|
|
void TQDesignerWidgetStack::setPageName( const TQCString& name )
|
|
{
|
|
if ( visibleWidget() )
|
|
visibleWidget()->setName( name );
|
|
}
|
|
|
|
int TQDesignerWidgetStack::count() const
|
|
{
|
|
return pages.count();
|
|
}
|
|
|
|
TQWidget* TQDesignerWidgetStack::page( int i ) const
|
|
{
|
|
if ( i < 0 || i >= count() )
|
|
return 0;
|
|
TQDesignerWidgetStack* that = (TQDesignerWidgetStack*) this;
|
|
return that->pages.at( i );
|
|
}
|
|
|
|
|
|
int TQDesignerWidgetStack::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.tqfind( p );
|
|
}
|
|
|
|
int TQDesignerWidgetStack::removePage( TQWidget *p )
|
|
{
|
|
int i = pages.tqfind( p );
|
|
pages.remove( p );
|
|
removeWidget( p );
|
|
setCurrentPage( 0 );
|
|
updateButtons();
|
|
return i;
|
|
}
|
|
|
|
|
|
int TQDesignerWizard::currentPageNum() const
|
|
{
|
|
for ( int i = 0; i < pageCount(); ++i ) {
|
|
if ( page( i ) == currentPage() )
|
|
return i;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void TQDesignerWizard::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 TQDesignerWizard::pageTitle() const
|
|
{
|
|
return title( currentPage() );
|
|
}
|
|
|
|
void TQDesignerWizard::setPageTitle( const TQString& title )
|
|
{
|
|
setTitle( currentPage(), title );
|
|
}
|
|
|
|
void TQDesignerWizard::setPageName( const TQCString& name )
|
|
{
|
|
if ( TQWizard::currentPage() )
|
|
TQWizard::currentPage()->setName( name );
|
|
}
|
|
|
|
TQCString TQDesignerWizard::pageName() const
|
|
{
|
|
if ( !TQWizard::currentPage() )
|
|
return 0;
|
|
return TQWizard::currentPage()->name();
|
|
}
|
|
|
|
int TQDesignerWizard::pageNum( TQWidget *p )
|
|
{
|
|
for ( int i = 0; i < pageCount(); ++i ) {
|
|
if ( page( i ) == p )
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void TQDesignerWizard::addPage( TQWidget *p, const TQString &t )
|
|
{
|
|
TQWizard::addPage( p, t );
|
|
if ( removedPages.tqfind( p ) )
|
|
removedPages.remove( p );
|
|
}
|
|
|
|
void TQDesignerWizard::removePage( TQWidget *p )
|
|
{
|
|
TQWizard::removePage( p );
|
|
removedPages.insert( p, p );
|
|
}
|
|
|
|
void TQDesignerWizard::insertPage( TQWidget *p, const TQString &t, int index )
|
|
{
|
|
TQWizard::insertPage( p, t, index );
|
|
if ( removedPages.tqfind( 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, tqlayouts and do other stuff
|
|
|
|
The widget factory offers functions to create widgets, create and
|
|
delete tqlayouts 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->tqmetaObject()->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.tqreplace( lst.at( i ), var );
|
|
}
|
|
defaultProperties->tqreplace( 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 tqparent. 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 *tqparent, const char *name, bool init, const TQRect *r, Qt::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, tqparent, name ? name : s, init, r, orient );
|
|
if ( ::tqqt_cast<TQScrollView*>(w) )
|
|
( (TQScrollView*)w )->disableSizeHintCaching();
|
|
if ( !w && WidgetDatabase::isCustomWidget( id ) )
|
|
w = createCustomWidget( tqparent, name ? name : s, MetaDataBase::customWidget( id ) );
|
|
if ( !w )
|
|
return 0;
|
|
MetaDataBase::addEntry( TQT_TQOBJECT(w) );
|
|
|
|
if ( !defaultProperties->tqcontains( id ) )
|
|
saveDefaultProperties( TQT_TQOBJECT(w), id );
|
|
if ( !changedProperties->tqcontains( id ) )
|
|
saveChangedProperties( TQT_TQOBJECT(w), id );
|
|
|
|
return w;
|
|
}
|
|
|
|
/*! Creates a tqlayout 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 *tqlayout, LayoutType type )
|
|
{
|
|
int spacing = MainWindow::self->currentLayoutDefaultSpacing();
|
|
int margin = 0;
|
|
|
|
int metaspacing = MetaDataBase::spacing( TQT_TQOBJECT(widget) );
|
|
int metamargin = MetaDataBase::margin( TQT_TQOBJECT(widget) );
|
|
|
|
if ( ::tqqt_cast<TQLayoutWidget*>(widget) &&
|
|
( WidgetDatabase::isContainer( WidgetDatabase::idFromClassName( WidgetFactory::classNameOf( TQT_TQOBJECT(widget) ) ) ) ||
|
|
widget && ::tqqt_cast<FormWindow*>(widget->tqparentWidget()) ) )
|
|
margin = MainWindow::self->currentLayoutDefaultMargin();
|
|
|
|
if ( !tqlayout && ::tqqt_cast<TQTabWidget*>(widget) )
|
|
widget = ((TQTabWidget*)widget)->currentPage();
|
|
|
|
if ( !tqlayout && ::tqqt_cast<TQWizard*>(widget) )
|
|
widget = ((TQWizard*)widget)->currentPage();
|
|
|
|
if ( !tqlayout && ::tqqt_cast<TQMainWindow*>(widget) )
|
|
widget = ((TQMainWindow*)widget)->centralWidget();
|
|
|
|
if ( !tqlayout && ::tqqt_cast<TQWidgetStack*>(widget) )
|
|
widget = ((TQWidgetStack*)widget)->visibleWidget();
|
|
|
|
if ( !tqlayout && ::tqqt_cast<TQToolBox*>(widget) )
|
|
widget = ((TQToolBox*)widget)->currentItem();
|
|
|
|
MetaDataBase::addEntry( TQT_TQOBJECT(widget) );
|
|
|
|
TQLayout *l = 0;
|
|
int align = 0;
|
|
if ( !tqlayout && ::tqqt_cast<TQGroupBox*>(widget) ) {
|
|
TQGroupBox *gb = (TQGroupBox*)widget;
|
|
gb->setColumnLayout( 0, Qt::Vertical );
|
|
tqlayout = gb->tqlayout();
|
|
tqlayout->setMargin( 0 );
|
|
tqlayout->setSpacing( 0 );
|
|
switch ( type ) {
|
|
case HBox:
|
|
l = new TQHBoxLayout( tqlayout );
|
|
break;
|
|
case VBox:
|
|
l = new TQVBoxLayout( tqlayout );
|
|
break;
|
|
case Grid:
|
|
l = new TQDesignerGridLayout( tqlayout );
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
align = TQt::AlignTop;
|
|
MetaDataBase::setMargin( TQT_TQOBJECT(gb), metamargin );
|
|
MetaDataBase::setSpacing( TQT_TQOBJECT(gb), metaspacing );
|
|
} else {
|
|
if ( tqlayout ) {
|
|
switch ( type ) {
|
|
case HBox:
|
|
l = new TQHBoxLayout( tqlayout );
|
|
break;
|
|
case VBox:
|
|
l = new TQVBoxLayout( tqlayout );
|
|
break;
|
|
case Grid:
|
|
l = new TQDesignerGridLayout( tqlayout );
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
MetaDataBase::addEntry( TQT_TQOBJECT(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 TQDesignerGridLayout( widget );
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
MetaDataBase::addEntry( TQT_TQOBJECT(l) );
|
|
if ( widget ) {
|
|
MetaDataBase::setMargin( TQT_TQOBJECT(widget), metamargin );
|
|
MetaDataBase::setSpacing( TQT_TQOBJECT(widget), metaspacing );
|
|
} else {
|
|
l->setMargin( margin );
|
|
l->setSpacing( spacing );
|
|
}
|
|
}
|
|
}
|
|
l->tqsetAlignment( align );
|
|
MetaDataBase::addEntry( TQT_TQOBJECT(l) );
|
|
return l;
|
|
}
|
|
|
|
void WidgetFactory::deleteLayout( TQWidget *widget )
|
|
{
|
|
if ( !widget )
|
|
return;
|
|
|
|
if ( ::tqqt_cast<TQTabWidget*>(widget) )
|
|
widget = ((TQTabWidget*)widget)->currentPage();
|
|
if ( ::tqqt_cast<TQWizard*>(widget) )
|
|
widget = ((TQWizard*)widget)->currentPage();
|
|
if ( ::tqqt_cast<TQMainWindow*>(widget) )
|
|
widget = ((TQMainWindow*)widget)->centralWidget();
|
|
if ( ::tqqt_cast<TQWidgetStack*>(widget) )
|
|
widget = ((TQWidgetStack*)widget)->visibleWidget();
|
|
if ( ::tqqt_cast<TQToolBox*>(widget) )
|
|
widget = ((TQToolBox*)widget)->currentItem();
|
|
delete widget->tqlayout();
|
|
}
|
|
|
|
/*! Factory functions for creating a widget of the type \a className
|
|
as child of \a tqparent 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 *tqparent, const char *name, bool init,
|
|
const TQRect *r, Qt::Orientation orient )
|
|
{
|
|
if ( className == TQPUSHBUTTON_OBJECT_NAME_STRING ) {
|
|
TQPushButton *b = 0;
|
|
if ( init ) {
|
|
b = new TQDesignerPushButton( tqparent, name );
|
|
b->setText( TQString::tqfromLatin1( name ) );
|
|
} else {
|
|
b = new TQDesignerPushButton( tqparent, name );
|
|
}
|
|
TQWidget *w = find_formwindow( b );
|
|
b->setAutoDefault( w && ::tqqt_cast<TQDialog*>(((FormWindow*)w)->mainContainer()) );
|
|
return b;
|
|
} else if ( className == TQTOOLBUTTON_OBJECT_NAME_STRING ) {
|
|
if ( init ) {
|
|
TQDesignerToolButton *tb = new TQDesignerToolButton( tqparent, name );
|
|
if ( ::tqqt_cast<TQToolBox*>(widgetOfContainer(tqparent))) {
|
|
tb->setUsesTextLabel(TRUE);
|
|
tb->setTextLabel("...");
|
|
tb->setAutoRaise(TRUE);
|
|
tb->setTextPosition(TQToolButton::BesideIcon);
|
|
} else {
|
|
tb->setText( "..." );
|
|
}
|
|
return tb;
|
|
}
|
|
return new TQDesignerToolButton( tqparent, name );
|
|
} else if ( className == TQCHECKBOX_OBJECT_NAME_STRING ) {
|
|
if ( init ) {
|
|
TQDesignerCheckBox *cb = new TQDesignerCheckBox( tqparent, name );
|
|
cb->setText( TQString::tqfromLatin1( name ) );
|
|
return cb;
|
|
}
|
|
return new TQDesignerCheckBox( tqparent, name );
|
|
} else if ( className == TQRADIOBUTTON_OBJECT_NAME_STRING ) {
|
|
if ( init ) {
|
|
TQDesignerRadioButton *rb = new TQDesignerRadioButton( tqparent, name );
|
|
rb->setText( TQString::tqfromLatin1( name ) );
|
|
return rb;
|
|
}
|
|
return new TQDesignerRadioButton( tqparent, name );
|
|
} else if ( className == TQGROUPBOX_OBJECT_NAME_STRING ) {
|
|
if ( init )
|
|
return new TQGroupBox( TQString::tqfromLatin1( name ), tqparent, name );
|
|
return new TQGroupBox( tqparent, name );
|
|
} else if ( className == TQBUTTONGROUP_OBJECT_NAME_STRING ) {
|
|
if ( init )
|
|
return new TQButtonGroup( TQString::tqfromLatin1( name ), tqparent, name );
|
|
return new TQButtonGroup( tqparent, name );
|
|
} else if ( className == TQICONVIEW_OBJECT_NAME_STRING ) {
|
|
#if !defined(TQT_NO_ICONVIEW)
|
|
TQIconView* iv = new TQIconView( tqparent, name );
|
|
if ( init )
|
|
(void) new TQIconViewItem( iv, i18n( "New Item" ) );
|
|
return iv;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
} else if ( className == TQTABLE_OBJECT_NAME_STRING ) {
|
|
#if !defined(TQT_NO_TABLE)
|
|
if ( init )
|
|
return new TQTable( 3, 3, tqparent, name );
|
|
return new TQTable( tqparent, name );
|
|
#else
|
|
return 0;
|
|
#endif
|
|
#ifndef TQT_NO_SQL
|
|
} else if ( className == TQDATATABLE_OBJECT_NAME_STRING ) {
|
|
return new TQDataTable( tqparent, name );
|
|
#endif //TQT_NO_SQL
|
|
} else if ( className == TQDATEEDIT_OBJECT_NAME_STRING ) {
|
|
return new TQDateEdit( tqparent, name );
|
|
} else if ( className == TQTIMEEDIT_OBJECT_NAME_STRING ) {
|
|
return new TQTimeEdit( tqparent, name );
|
|
} else if ( className == TQDATETIMEEDIT_OBJECT_NAME_STRING ) {
|
|
return new TQDateTimeEdit( tqparent, name );
|
|
}
|
|
else if ( className == TQLISTBOX_OBJECT_NAME_STRING ) {
|
|
TQListBox* lb = new TQListBox( tqparent, name );
|
|
if ( init ) {
|
|
lb->insertItem( i18n( "New Item" ) );
|
|
lb->setCurrentItem( 0 );
|
|
}
|
|
return lb;
|
|
} else if ( className == TQLISTVIEW_OBJECT_NAME_STRING ) {
|
|
TQListView *lv = new TQListView( tqparent, 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_OBJECT_NAME_STRING )
|
|
return new TQLineEdit( tqparent, name );
|
|
else if ( className == TQSPINBOX_OBJECT_NAME_STRING )
|
|
return new TQSpinBox( tqparent, name );
|
|
else if ( className == TQSPLITTER_OBJECT_NAME_STRING )
|
|
return new TQSplitter( tqparent, name );
|
|
else if ( className == TQMULTILINEEDIT_OBJECT_NAME_STRING )
|
|
return new TQMultiLineEdit( tqparent, name );
|
|
else if ( className == TQTEXTEDIT_OBJECT_NAME_STRING )
|
|
return new TQTextEdit( tqparent, name );
|
|
else if ( className == TQLABEL_OBJECT_NAME_STRING || className == "TextLabel" ) {
|
|
TQDesignerLabel *l = new TQDesignerLabel( tqparent, name );
|
|
if ( init ) {
|
|
l->setText( TQString::tqfromLatin1( name ) );
|
|
MetaDataBase::addEntry( TQT_TQOBJECT(l) );
|
|
MetaDataBase::setPropertyChanged( TQT_TQOBJECT(l), "text", TRUE );
|
|
}
|
|
return l;
|
|
} else if ( className == "PixmapLabel" ) {
|
|
TQDesignerLabel *l = new TQDesignerLabel( tqparent, name );
|
|
if ( init ) {
|
|
l->setPixmap( BarIcon( "designer_qtlogo.png", KDevDesignerPartFactory::instance() ) );
|
|
l->setScaledContents( TRUE );
|
|
MetaDataBase::addEntry( TQT_TQOBJECT(l) );
|
|
MetaDataBase::setPropertyChanged( TQT_TQOBJECT(l), "pixmap", TRUE );
|
|
MetaDataBase::setPropertyChanged( TQT_TQOBJECT(l), "scaledContents", TRUE );
|
|
}
|
|
return l;
|
|
} else if ( className == TQLAYOUTWIDGET_OBJECT_NAME_STRING )
|
|
return new TQLayoutWidget( tqparent, name );
|
|
else if ( className == TQTABWIDGET_OBJECT_NAME_STRING ) {
|
|
TQTabWidget *tw = new TQDesignerTabWidget( tqparent, name );
|
|
if ( init ) {
|
|
FormWindow *fw = find_formwindow( tqparent );
|
|
TQWidget *w = fw ? new TQDesignerWidget( fw, tw, "tab" ) : new TQWidget( tw, "tab" );
|
|
tw->addTab( w, i18n("Tab 1") );
|
|
MetaDataBase::addEntry( TQT_TQOBJECT(w) );
|
|
w = fw ? new TQDesignerWidget( fw, tw, "tab" ) : new TQWidget( tw, "tab" );
|
|
tw->addTab( w, i18n("Tab 2") );
|
|
MetaDataBase::addEntry( TQT_TQOBJECT(tw) );
|
|
MetaDataBase::addEntry( TQT_TQOBJECT(w) );
|
|
}
|
|
return tw;
|
|
} else if ( className == TQWIDGETSTACK_OBJECT_NAME_STRING ) {
|
|
TQDesignerWidgetStack *ws = new TQDesignerWidgetStack( tqparent, name );
|
|
if ( init ) {
|
|
FormWindow *fw = find_formwindow( tqparent );
|
|
TQWidget *w = fw ? new TQDesignerWidget( fw, ws, "WStackPage" ) : new TQWidget( ws, "WStackPage" );
|
|
ws->insertPage( w );
|
|
MetaDataBase::addEntry( TQT_TQOBJECT(w) );
|
|
MetaDataBase::addEntry( TQT_TQOBJECT(ws) );
|
|
}
|
|
return ws;
|
|
} else if ( className == TQCOMBOBOX_OBJECT_NAME_STRING ) {
|
|
return new TQComboBox( FALSE, tqparent, name );
|
|
} else if ( className == TQWIDGET_OBJECT_NAME_STRING ) {
|
|
if ( tqparent &&
|
|
( ::tqqt_cast<FormWindow*>(tqparent) ||
|
|
::tqqt_cast<TQWizard*>(tqparent) ||
|
|
::tqqt_cast<TQTabWidget*>(tqparent) ||
|
|
::tqqt_cast<TQWidgetStack*>(tqparent) ||
|
|
::tqqt_cast<TQToolBox*>(tqparent) ||
|
|
::tqqt_cast<TQMainWindow*>(tqparent) ) ) {
|
|
FormWindow *fw = find_formwindow( tqparent );
|
|
if ( fw ) {
|
|
TQDesignerWidget *dw = new TQDesignerWidget( fw, tqparent, name );
|
|
MetaDataBase::addEntry( TQT_TQOBJECT(dw) );
|
|
return dw;
|
|
}
|
|
}
|
|
return new TQWidget( tqparent, name );
|
|
} else if ( className == TQDIALOG_OBJECT_NAME_STRING ) {
|
|
TQDialog *dia = 0;
|
|
if ( ::tqqt_cast<FormWindow*>(tqparent) )
|
|
dia = new TQDesignerDialog( (FormWindow*)tqparent, tqparent, name );
|
|
else
|
|
dia = new TQDialog( tqparent, name );
|
|
#if defined(TQT_NON_COMMERCIAL)
|
|
if ( ::tqqt_cast<MainWindow*>(tqparent) )
|
|
#else
|
|
if ( tqparent )
|
|
#endif
|
|
dia->reparent( tqparent, TQPoint( 0, 0 ), TRUE );
|
|
return dia;
|
|
} else if ( className == TQWIZARD_OBJECT_NAME_STRING ) {
|
|
TQWizard *wiz = new TQDesignerWizard( tqparent, name );
|
|
#if defined(TQT_NON_COMMERCIAL)
|
|
if ( ::tqqt_cast<MainWindow*>(tqparent) )
|
|
#else
|
|
if ( tqparent )
|
|
#endif
|
|
wiz->reparent( tqparent, TQPoint( 0, 0 ), TRUE );
|
|
if ( init && ::tqqt_cast<FormWindow*>(tqparent) ) {
|
|
TQDesignerWidget *dw = new TQDesignerWidget( (FormWindow*)tqparent, wiz, "WizardPage" );
|
|
MetaDataBase::addEntry( TQT_TQOBJECT(dw) );
|
|
wiz->addPage( dw, i18n( "Page" ) );
|
|
TQTimer::singleShot( 0, wiz, TQT_SLOT( next() ) );
|
|
}
|
|
return wiz;
|
|
} else if ( className == "Spacer" ) {
|
|
Spacer *s = new Spacer( tqparent, name );
|
|
MetaDataBase::addEntry( TQT_TQOBJECT(s) );
|
|
MetaDataBase::setPropertyChanged( TQT_TQOBJECT(s), "orientation", TRUE );
|
|
MetaDataBase::setPropertyChanged( TQT_TQOBJECT(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( Qt::Vertical );
|
|
else
|
|
s->setOrientation( Qt::Horizontal );
|
|
return s;
|
|
} else if ( className == TQLCDNUMBER_OBJECT_NAME_STRING )
|
|
return new TQLCDNumber( tqparent, name );
|
|
else if ( className == TQPROGRESSBAR_OBJECT_NAME_STRING )
|
|
return new TQProgressBar( tqparent, name );
|
|
else if ( className == TQTEXTVIEW_OBJECT_NAME_STRING )
|
|
return new TQTextView( tqparent, name );
|
|
else if ( className == TQTEXTBROWSER_OBJECT_NAME_STRING )
|
|
return new TQTextBrowser( tqparent, name );
|
|
else if ( className == TQDIAL_OBJECT_NAME_STRING )
|
|
return new TQDial( tqparent, name );
|
|
else if ( className == TQSLIDER_OBJECT_NAME_STRING ) {
|
|
TQSlider *s = new TQSlider( tqparent, 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( Qt::Horizontal );
|
|
MetaDataBase::addEntry( TQT_TQOBJECT(s) );
|
|
MetaDataBase::setPropertyChanged( TQT_TQOBJECT(s), "orientation", TRUE );
|
|
return s;
|
|
} else if ( className == TQSCROLLBAR_OBJECT_NAME_STRING ) {
|
|
TQScrollBar *s = new TQScrollBar( tqparent, 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( Qt::Horizontal );
|
|
MetaDataBase::addEntry( TQT_TQOBJECT(s) );
|
|
MetaDataBase::setPropertyChanged( TQT_TQOBJECT(s), "orientation", TRUE );
|
|
return s;
|
|
} else if ( className == TQFRAME_OBJECT_NAME_STRING ) {
|
|
if ( !init )
|
|
return new TQFrame( tqparent, name );
|
|
TQFrame *f = new TQFrame( tqparent, name );
|
|
f->setFrameStyle( TQFrame::StyledPanel | TQFrame::Raised );
|
|
return f;
|
|
} else if ( className == "Line" ) {
|
|
Line *l = new Line( tqparent, name );
|
|
MetaDataBase::addEntry( TQT_TQOBJECT(l) );
|
|
MetaDataBase::setPropertyChanged( TQT_TQOBJECT(l), "orientation", TRUE );
|
|
MetaDataBase::setPropertyChanged( TQT_TQOBJECT(l), "frameShadow", TRUE );
|
|
MetaDataBase::setPropertyChanged( TQT_TQOBJECT(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( Qt::Vertical );
|
|
return l;
|
|
} else if ( className == TQMAINWINDOW_OBJECT_NAME_STRING ) {
|
|
TQMainWindow *mw = new TQMainWindow( tqparent, name, 0 );
|
|
mw->setDockEnabled( TQt::DockMinimized, FALSE );
|
|
TQDesignerWidget *dw = new TQDesignerWidget( (FormWindow*)tqparent, mw, "central widget" );
|
|
mw->setDockMenuEnabled( FALSE );
|
|
MetaDataBase::addEntry( TQT_TQOBJECT(dw) );
|
|
mw->setCentralWidget( dw );
|
|
(void)mw->statusBar();
|
|
dw->show();
|
|
return mw;
|
|
} else if ( className == TQTOOLBOX_OBJECT_NAME_STRING ) {
|
|
if ( !init )
|
|
return new TQDesignerToolBox( tqparent, name );
|
|
TQToolBox *tb = new TQDesignerToolBox( tqparent, name );
|
|
FormWindow *fw = find_formwindow( tqparent );
|
|
TQWidget *w = fw ? new TQDesignerWidget( fw, tb, "page1" ) :
|
|
new TQWidget( tb, "page1" );
|
|
tb->addItem( w, i18n("Page 1") );
|
|
MetaDataBase::addEntry( TQT_TQOBJECT(w) );
|
|
w = fw ? new TQDesignerWidget( fw, tb, "page2" ) : new TQWidget( tb, "page2" );
|
|
tb->addItem( w, i18n("Page 2") );
|
|
MetaDataBase::addEntry( TQT_TQOBJECT(tb) );
|
|
MetaDataBase::addEntry( TQT_TQOBJECT(w) );
|
|
return tb;
|
|
}
|
|
#ifndef TQT_NO_SQL
|
|
else if ( className == TQDATABROWSER_OBJECT_NAME_STRING ) {
|
|
TQWidget *w = new TQDesignerDataBrowser( tqparent, name );
|
|
if ( tqparent )
|
|
w->reparent( tqparent, TQPoint( 0, 0 ), TRUE );
|
|
return w;
|
|
} else if ( className == TQDATAVIEW_OBJECT_NAME_STRING ) {
|
|
TQWidget *w = new TQDesignerDataView( tqparent, name );
|
|
if ( tqparent )
|
|
w->reparent( tqparent, TQPoint( 0, 0 ), TRUE );
|
|
return w;
|
|
}
|
|
#endif
|
|
|
|
WidgetInterface *iface = 0;
|
|
widgetManager()->queryInterface( className, &iface );
|
|
if ( !iface )
|
|
return 0;
|
|
|
|
TQWidget *w = iface->create( className, tqparent, 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 tqlayout of the widget is. Returns \c HBox,
|
|
\c VBox, \c Grid or \c NoLayout. \a tqlayout points to this
|
|
TQWidget::tqlayout() of \a w or to 0 after the function call.
|
|
*/
|
|
|
|
WidgetFactory::LayoutType WidgetFactory::tqlayoutType( TQWidget *w, TQLayout *&tqlayout )
|
|
{
|
|
tqlayout = 0;
|
|
|
|
if ( ::tqqt_cast<TQTabWidget*>(w) )
|
|
w = ((TQTabWidget*)w)->currentPage();
|
|
if ( ::tqqt_cast<TQWizard*>(w) )
|
|
w = ((TQWizard*)w)->currentPage();
|
|
if ( ::tqqt_cast<TQMainWindow*>(w) )
|
|
w = ((TQMainWindow*)w)->centralWidget();
|
|
if ( ::tqqt_cast<TQWidgetStack*>(w) )
|
|
w = ((TQWidgetStack*)w)->visibleWidget();
|
|
if ( ::tqqt_cast<TQToolBox*>(w) )
|
|
w = ((TQToolBox*)w)->currentItem();
|
|
|
|
if ( ::tqqt_cast<TQSplitter*>(w) )
|
|
return ( (TQSplitter*)w )->orientation() ==Qt::Horizontal ? HBox : VBox;
|
|
|
|
if ( !w || !w->tqlayout() )
|
|
return NoLayout;
|
|
TQLayout *lay = w->tqlayout();
|
|
|
|
if ( ::tqqt_cast<TQGroupBox*>(w) ) {
|
|
TQObjectList *l = TQT_TQOBJECT(lay)->queryList( TQLAYOUT_OBJECT_NAME_STRING );
|
|
if ( l && l->first() )
|
|
lay = (TQLayout*)l->first();
|
|
delete l;
|
|
}
|
|
tqlayout = lay;
|
|
|
|
if ( ::tqqt_cast<TQHBoxLayout*>(lay) )
|
|
return HBox;
|
|
else if ( ::tqqt_cast<TQVBoxLayout*>(lay) )
|
|
return VBox;
|
|
else if ( ::tqqt_cast<TQGridLayout*>(lay) )
|
|
return Grid;
|
|
return NoLayout;
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
*/
|
|
WidgetFactory::LayoutType WidgetFactory::tqlayoutType( TQLayout *tqlayout )
|
|
{
|
|
if ( ::tqqt_cast<TQHBoxLayout*>(tqlayout) )
|
|
return HBox;
|
|
else if ( ::tqqt_cast<TQVBoxLayout*>(tqlayout) )
|
|
return VBox;
|
|
else if ( ::tqqt_cast<TQGridLayout*>(tqlayout) )
|
|
return Grid;
|
|
return NoLayout;
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
*/
|
|
WidgetFactory::LayoutType WidgetFactory::tqlayoutType( TQWidget *w )
|
|
{
|
|
TQLayout *l = 0;
|
|
return tqlayoutType( w, l );
|
|
}
|
|
|
|
|
|
TQWidget *WidgetFactory::tqlayoutParent( TQLayout *tqlayout )
|
|
{
|
|
TQObject *o = TQT_TQOBJECT(tqlayout);
|
|
while ( o ) {
|
|
if ( o->isWidgetType() )
|
|
return (TQWidget*)o;
|
|
o = o->tqparent();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*! Returns the widget into which tqchildren 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 ( ::tqqt_cast<TQTabWidget*>(w) )
|
|
return ((TQTabWidget*)w)->currentPage();
|
|
if ( ::tqqt_cast<TQWizard*>(w) )
|
|
return ((TQWizard*)w)->currentPage();
|
|
if ( ::tqqt_cast<TQWidgetStack*>(w) )
|
|
return ((TQWidgetStack*)w)->visibleWidget();
|
|
if ( ::tqqt_cast<TQToolBox*>(w) )
|
|
return ((TQToolBox*)w)->currentItem();
|
|
if ( ::tqqt_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 tqparent or grand tqparent of \a w
|
|
(e.g. when working with a tabwidget and \a w is the container which
|
|
contains and tqlayouts childs, but the actual widget known to the
|
|
designer is the tabwidget which is the tqparent of \a w. So this
|
|
function returns the tabwidget then.)
|
|
*/
|
|
|
|
TQWidget* WidgetFactory::widgetOfContainer( TQWidget *w )
|
|
{
|
|
if ( w && ::tqqt_cast<TQWidgetStack*>(w->tqparentWidget()) )
|
|
w = w->tqparentWidget();
|
|
if ( w->tqparentWidget() && w->tqparentWidget()->tqparentWidget() &&
|
|
w->tqparentWidget()->tqparentWidget()->tqparentWidget() &&
|
|
::tqqt_cast<TQToolBox*>(w->tqparentWidget()->tqparentWidget()->tqparentWidget()) )
|
|
return w->tqparentWidget()->tqparentWidget()->tqparentWidget();
|
|
while ( w ) {
|
|
int id = WidgetDatabase::idFromClassName( WidgetFactory::classNameOf( TQT_TQOBJECT(w) ) );
|
|
if ( WidgetDatabase::isContainer( id ) ||
|
|
w && ::tqqt_cast<FormWindow*>(w->tqparentWidget()) )
|
|
return w;
|
|
w = w->tqparentWidget();
|
|
}
|
|
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 ( ::tqqt_cast<TQTabBar*>(o) )
|
|
return ( lastWasAPassiveInteractor = TRUE );
|
|
else if ( ::tqqt_cast<TQSizeGrip*>(o) )
|
|
return ( lastWasAPassiveInteractor = TRUE );
|
|
else if ( ::tqqt_cast<TQButton*>(o) &&
|
|
( ::tqqt_cast<TQTabBar*>(o->tqparent()) || ::tqqt_cast<TQToolBox*>(o->tqparent()) ) )
|
|
return ( lastWasAPassiveInteractor = TRUE );
|
|
else if ( ::tqqt_cast<TQPushButton*>(o) && ::tqqt_cast<TQWizard*>(o->tqparent()) )
|
|
return ( lastWasAPassiveInteractor = TRUE );
|
|
else if ( ::tqqt_cast<TQMenuBar*>(o) && ::tqqt_cast<TQMainWindow*>(o->tqparent()) )
|
|
return ( lastWasAPassiveInteractor = TRUE );
|
|
// else if ( ::tqqt_cast<TQDockWindowHandle*>(o) )
|
|
else if ( o->inherits( TQDOCKWINDOWHANDLE_OBJECT_NAME_STRING ) )
|
|
return ( lastWasAPassiveInteractor = TRUE );
|
|
// else if ( ::tqqt_cast<TQHideDock*>(o) )
|
|
else if ( o->inherits( TQHIDEDOCK_OBJECT_NAME_STRING ) )
|
|
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 && !::tqqt_cast<FormWindow*>(w) ) {
|
|
widgetManager()->queryInterface( classNameOf( w ), &iface );
|
|
w = w->tqparentWidget();
|
|
}
|
|
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 ( ::tqqt_cast<TQDesignerTabWidget*>(o) )
|
|
return TQTABWIDGET_OBJECT_NAME_STRING;
|
|
else if ( ::tqqt_cast<TQDesignerWidgetStack*>(o) )
|
|
return TQWIDGETSTACK_OBJECT_NAME_STRING;
|
|
else if ( ::tqqt_cast<TQWidgetStack*>(o) )
|
|
return "TQWeDoNotWantToBreakTabWidget";
|
|
else if ( ::tqqt_cast<TQDesignerDialog*>(o) )
|
|
return TQDIALOG_OBJECT_NAME_STRING;
|
|
else if ( ::tqqt_cast<TQDesignerWidget*>(o) )
|
|
return TQWIDGET_OBJECT_NAME_STRING;
|
|
else if ( o->inherits( "CustomWidget" ) )
|
|
return ( (CustomWidget*)o )->realClassName().latin1();
|
|
else if ( ::tqqt_cast<TQDesignerLabel*>(o) )
|
|
return TQLABEL_OBJECT_NAME_STRING;
|
|
else if ( ::tqqt_cast<TQDesignerWizard*>(o) )
|
|
return TQWIZARD_OBJECT_NAME_STRING;
|
|
else if ( ::tqqt_cast<TQDesignerPushButton*>(o) )
|
|
return TQPUSHBUTTON_OBJECT_NAME_STRING;
|
|
else if ( ::tqqt_cast<TQDesignerToolButton*>(o) )
|
|
return TQTOOLBUTTON_OBJECT_NAME_STRING;
|
|
else if ( ::tqqt_cast<TQDesignerRadioButton*>(o) )
|
|
return TQRADIOBUTTON_OBJECT_NAME_STRING;
|
|
else if ( ::tqqt_cast<TQDesignerCheckBox*>(o) )
|
|
return TQCHECKBOX_OBJECT_NAME_STRING;
|
|
else if ( ::tqqt_cast<MenuBarEditor*>(o) )
|
|
return TQMENUBAR_OBJECT_NAME_STRING;
|
|
else if ( ::tqqt_cast<TQDesignerToolBar*>(o) )
|
|
return TQTOOLBAR_OBJECT_NAME_STRING;
|
|
else if ( ::tqqt_cast<TQDesignerAction*>(o) )
|
|
return TQACTION_OBJECT_NAME_STRING;
|
|
else if ( ::tqqt_cast<TQDesignerActionGroup*>(o) )
|
|
return TQACTIONGROUP_OBJECT_NAME_STRING;
|
|
else if ( ::tqqt_cast<PopupMenuEditor*>(o) )
|
|
return TQPOPUPMENU_OBJECT_NAME_STRING;
|
|
else if ( ::tqqt_cast<TQDesignerToolBox*>(o) )
|
|
return TQTOOLBOX_OBJECT_NAME_STRING;
|
|
#ifndef TQT_NO_SQL
|
|
else if ( ::tqqt_cast<TQDesignerDataBrowser*>(o) )
|
|
return TQDATABROWSER_OBJECT_NAME_STRING;
|
|
else if ( ::tqqt_cast<TQDesignerDataView*>(o) )
|
|
return TQDATAVIEW_OBJECT_NAME_STRING;
|
|
#endif
|
|
return o->className();
|
|
}
|
|
|
|
TQString WidgetFactory::defaultSignal( TQObject *w )
|
|
{
|
|
if ( ::tqqt_cast<TQRadioButton*>(w) || ::tqqt_cast<TQCheckBox*>(w) )
|
|
return "toggled";
|
|
else if ( ::tqqt_cast<TQButton*>(w) || ::tqqt_cast<TQButtonGroup*>(w) )
|
|
return "clicked";
|
|
else if ( ::tqqt_cast<TQTextBrowser*>(w) )
|
|
return "linkClicked";
|
|
else if ( ::tqqt_cast<TQLineEdit*>(w) || ::tqqt_cast<TQTextEdit*>(w) )
|
|
return "textChanged";
|
|
else if ( ::tqqt_cast<TQListView*>(w) || ::tqqt_cast<TQIconView*>(w) ||
|
|
::tqqt_cast<TQListBox*>(w) || ::tqqt_cast<TQTable*>(w) )
|
|
return "selectionChanged";
|
|
else if ( ::tqqt_cast<TQTabWidget*>(w) )
|
|
return "selected";
|
|
else if ( ::tqqt_cast<TQToolBox*>(w) )
|
|
return "currentChanged";
|
|
else if ( ::tqqt_cast<TQWidgetStack*>(w) )
|
|
return "aboutToShow";
|
|
else if ( ::tqqt_cast<TQSpinBox*>(w) || ::tqqt_cast<TQSlider*>(w) ||
|
|
::tqqt_cast<TQScrollBar*>(w) || ::tqqt_cast<TQDateEdit*>(w) ||
|
|
::tqqt_cast<TQTimeEdit*>(w) || ::tqqt_cast<TQDateTimeEdit*>(w) ||
|
|
::tqqt_cast<TQDial*>(w) )
|
|
return "valueChanged";
|
|
else if ( ::tqqt_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 ( !::tqqt_cast<TQDesignerToolBar*>(o) && !::tqqt_cast<MenuBarEditor*>(o) )
|
|
MetaDataBase::setPropertyChanged( o, "geometry", TRUE );
|
|
|
|
if ( ::tqqt_cast<TQPushButton*>(o) ||
|
|
::tqqt_cast<TQRadioButton*>(o) ||
|
|
::tqqt_cast<TQCheckBox*>(o) ||
|
|
::tqqt_cast<TQToolButton*>(o) ) {
|
|
if (::tqqt_cast<TQToolButton*>(o) && ::tqqt_cast<TQToolBox*>(widgetOfContainer((TQWidget*)o->tqparent()))) {
|
|
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 ( ::tqqt_cast<TQGroupBox*>(o) )
|
|
MetaDataBase::setPropertyChanged( o, "title", TRUE );
|
|
else if ( o->isA( TQFRAME_OBJECT_NAME_STRING ) ) {
|
|
MetaDataBase::setPropertyChanged( o, "frameShadow", TRUE );
|
|
MetaDataBase::setPropertyChanged( o, "frameShape", TRUE );
|
|
} else if ( ::tqqt_cast<TQTabWidget*>(o) || ::tqqt_cast<TQWizard*>(o) ) {
|
|
MetaDataBase::setPropertyChanged( o, "pageTitle", TRUE );
|
|
MetaDataBase::setPropertyChanged( o, "pageName", TRUE );
|
|
MetaDataBase::setPropertyChanged( o, "currentPage", TRUE );
|
|
} else if ( ::tqqt_cast<TQWidgetStack*>(o) ) {
|
|
MetaDataBase::setPropertyChanged( o, "currentPage", TRUE );
|
|
MetaDataBase::setPropertyChanged( o, "pageName", TRUE );
|
|
} else if ( ::tqqt_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 ( ::tqqt_cast<TQTable*>(o) ) {
|
|
# ifndef TQT_NO_SQL
|
|
if (!::tqqt_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 ( ::tqqt_cast<TQSplitter*>(o) ) {
|
|
MetaDataBase::setPropertyChanged( o, "orientation", TRUE );
|
|
} else if ( ::tqqt_cast<TQDesignerToolBar*>(o) ) {
|
|
MetaDataBase::setPropertyChanged( o, "label", TRUE );
|
|
} else if ( ::tqqt_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.tqcontains( "ListBox" ) )
|
|
return TRUE;
|
|
if ( className.tqcontains( "ComboBox" ) )
|
|
return TRUE;
|
|
if ( className.tqcontains( "ListView" ) )
|
|
return TRUE;
|
|
if ( className.tqcontains( "IconView" ) )
|
|
return TRUE;
|
|
if ( className == TQTEXTEDIT_OBJECT_NAME_STRING || className == TQMULTILINEEDIT_OBJECT_NAME_STRING )
|
|
return TRUE;
|
|
if ( ::tqqt_cast<TQTable*>(editorWidget) != 0 )
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
bool WidgetFactory::hasItems( int id, TQObject *editorWidget )
|
|
{
|
|
TQString className = WidgetDatabase::className( id );
|
|
|
|
if ( className.tqcontains( "ListBox" ) || className.tqcontains( "ListView" ) ||
|
|
className.tqcontains( "IconView" ) || className.tqcontains( "ComboBox" ) ||
|
|
::tqqt_cast<TQTable*>(editorWidget) != 0 )
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void WidgetFactory::editWidget( int id, TQWidget *tqparent, TQWidget *editWidget, FormWindow *fw )
|
|
{
|
|
TQString className = WidgetDatabase::className( id );
|
|
|
|
if ( className.tqcontains( "ListBox" ) ) {
|
|
if ( !::tqqt_cast<TQListBox*>(editWidget) )
|
|
return;
|
|
ListBoxEditor *e = new ListBoxEditor( tqparent, editWidget, fw );
|
|
e->exec();
|
|
delete e;
|
|
return;
|
|
}
|
|
|
|
if ( className.tqcontains( "ComboBox" ) ) {
|
|
if ( !::tqqt_cast<TQComboBox*>(editWidget) )
|
|
return;
|
|
TQComboBox *cb = (TQComboBox*)editWidget;
|
|
ListBoxEditor *e = new ListBoxEditor( tqparent, cb->listBox(), fw );
|
|
e->exec();
|
|
delete e;
|
|
cb->update();
|
|
return;
|
|
}
|
|
|
|
if ( className.tqcontains( "ListView" ) ) {
|
|
if ( !::tqqt_cast<TQListView*>(editWidget) )
|
|
return;
|
|
TQListView *lv = (TQListView*)editWidget;
|
|
ListViewEditor *e = new ListViewEditor( tqparent, lv, fw );
|
|
e->exec();
|
|
delete e;
|
|
return;
|
|
}
|
|
|
|
if ( className.tqcontains( "IconView" ) ) {
|
|
if ( !::tqqt_cast<TQIconView*>(editWidget) )
|
|
return;
|
|
IconViewEditor *e = new IconViewEditor( tqparent, editWidget, fw );
|
|
e->exec();
|
|
delete e;
|
|
return;
|
|
}
|
|
|
|
if ( className == TQMULTILINEEDIT_OBJECT_NAME_STRING || className == TQTEXTEDIT_OBJECT_NAME_STRING ) {
|
|
MultiLineEditor *e = new MultiLineEditor( FALSE, TRUE, tqparent, editWidget, fw );
|
|
e->exec();
|
|
delete e;
|
|
return;
|
|
}
|
|
#ifndef TQT_NO_TABLE
|
|
if (::tqqt_cast<TQTable*>(editWidget) != 0) {
|
|
TableEditor *e = new TableEditor( tqparent, 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->tqfind( WidgetDatabase::idFromClassName( WidgetFactory::classNameOf( w ) ) );
|
|
return l.tqfindIndex( propName ) == -1;
|
|
}
|
|
|
|
bool WidgetFactory::resetProperty( TQObject *w, const TQString &propName )
|
|
{
|
|
const TQMetaProperty *p = w->tqmetaObject()->property( w->tqmetaObject()->
|
|
tqfindProperty( 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, "tqalignment" ).toInt();
|
|
return TQVariant( ( v & WordBreak ) == WordBreak, 0 );
|
|
} else if ( propName == "toolTip" || propName == "whatsThis" ) {
|
|
return TQVariant( TQString::tqfromLatin1( "" ) );
|
|
} else if ( w->inherits( "CustomWidget" ) ) {
|
|
return TQVariant();
|
|
} else if ( propName == "frameworkCode" ) {
|
|
return TQVariant( TRUE, 0 );
|
|
} else if ( propName == "tqlayoutMargin" || propName == "tqlayoutSpacing" ) {
|
|
return TQVariant( -1 );
|
|
}
|
|
|
|
return *( *defaultProperties->tqfind( WidgetDatabase::idFromClassName( classNameOf( w ) ) ) ).tqfind( propName );
|
|
}
|
|
|
|
TQString WidgetFactory::defaultCurrentItem( TQObject *w, const TQString &propName )
|
|
{
|
|
const TQMetaProperty *p = w->tqmetaObject()->
|
|
property( w->tqmetaObject()->tqfindProperty( propName, TRUE ), TRUE );
|
|
if ( !p ) {
|
|
int v = defaultValue( w, "tqalignment" ).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 *tqparent, const char *name, MetaDataBase::CustomWidget *w )
|
|
{
|
|
if ( !w )
|
|
return 0;
|
|
return new CustomWidget( tqparent, name, w );
|
|
}
|
|
|
|
TQVariant WidgetFactory::property( TQObject *w, const char *name )
|
|
{
|
|
int id = w->tqmetaObject()->tqfindProperty( name, TRUE );
|
|
const TQMetaProperty* p = w->tqmetaObject()->property( id, TRUE );
|
|
if ( !p || !p->isValid() )
|
|
return MetaDataBase::fakeProperty( w, name );
|
|
return w->property( name );
|
|
}
|
|
|
|
void TQDesignerLabel::updateBuddy()
|
|
{
|
|
|
|
if ( myBuddy.isEmpty() )
|
|
return;
|
|
|
|
TQObjectList *l = tqtopLevelWidget()->queryList( TQWIDGET_OBJECT_NAME_STRING, myBuddy, FALSE, TRUE );
|
|
if ( !l || !l->first() ) {
|
|
delete l;
|
|
return;
|
|
}
|
|
|
|
TQLabel::setBuddy( (TQWidget*)l->first() );
|
|
delete l;
|
|
}
|
|
|
|
|
|
void TQDesignerWidget::resizeEvent( TQResizeEvent* e)
|
|
{
|
|
if ( need_frame ) {
|
|
TQPainter p(this);
|
|
p.setPen( backgroundColor() );
|
|
p.drawRect( TQRect( TQPoint(0,0), e->oldSize() ) );
|
|
}
|
|
}
|
|
|
|
void TQDesignerWidget::paintEvent( TQPaintEvent *e )
|
|
{
|
|
if ( need_frame ) {
|
|
TQPainter p(this);
|
|
p.setPen( backgroundColor().dark() );
|
|
p.drawRect( rect() );
|
|
}
|
|
formwindow->paintGrid( this, e );
|
|
}
|
|
|
|
void TQDesignerDialog::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 tqparent tqlayout changes (e.g., from a TQHBoxLayout
|
|
to a TQVBoxLayout), because of the (illogical) way tqlayouting works.
|
|
*/
|
|
void TQLayoutWidget::updateSizePolicy()
|
|
{
|
|
if ( childrenListObject().isEmpty() || childrenListObject().count() == 0 ) {
|
|
sp = TQWidget::tqsizePolicy();
|
|
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 ( tqlayout() ) {
|
|
/*
|
|
tqparentLayout is set to the tqparent tqlayout if there is one and if it is
|
|
top level, in which case tqlayouting is illogical.
|
|
*/
|
|
TQLayout *tqparentLayout = 0;
|
|
if ( tqparent() && tqparent()->isWidgetType() ) {
|
|
tqparentLayout = ((TQWidget *)tqparent())->tqlayout();
|
|
if ( tqparentLayout &&
|
|
::tqqt_cast<TQLayoutWidget*>(tqparentLayout->mainWidget()) )
|
|
tqparentLayout = 0;
|
|
}
|
|
|
|
TQObjectListIt it( childrenListObject() );
|
|
TQObject *o;
|
|
|
|
if ( ::tqqt_cast<TQVBoxLayout*>(tqlayout()) ) {
|
|
if ( ::tqqt_cast<TQHBoxLayout*>(tqparentLayout) )
|
|
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->tqsizePolicy().mayGrowHorizontally() )
|
|
ht &= ~TQSizePolicy::Minimum;
|
|
if ( !w->tqsizePolicy().mayShrinkHorizontally() )
|
|
ht &= ~TQSizePolicy::Maximum;
|
|
if ( w->tqsizePolicy().mayGrowVertically() )
|
|
vt |= TQSizePolicy::Minimum;
|
|
if ( w->tqsizePolicy().mayShrinkVertically() )
|
|
vt |= TQSizePolicy::Maximum;
|
|
}
|
|
} else if ( ::tqqt_cast<TQHBoxLayout*>(tqlayout()) ) {
|
|
if ( ::tqqt_cast<TQVBoxLayout*>(tqparentLayout) )
|
|
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->tqsizePolicy().mayGrowHorizontally() )
|
|
ht |= TQSizePolicy::Minimum;
|
|
if ( w->tqsizePolicy().mayShrinkHorizontally() )
|
|
ht |= TQSizePolicy::Maximum;
|
|
if ( !w->tqsizePolicy().mayGrowVertically() )
|
|
vt &= ~TQSizePolicy::Minimum;
|
|
if ( !w->tqsizePolicy().mayShrinkVertically() )
|
|
vt &= ~TQSizePolicy::Maximum;
|
|
}
|
|
} else if ( ::tqqt_cast<TQGridLayout*>(tqlayout()) ) {
|
|
ht = TQSizePolicy::Fixed;
|
|
vt = TQSizePolicy::Fixed;
|
|
if ( tqparentLayout ) {
|
|
if ( ::tqqt_cast<TQVBoxLayout*>(tqparentLayout) )
|
|
ht = TQSizePolicy::Minimum;
|
|
else if ( ::tqqt_cast<TQHBoxLayout*>(tqparentLayout) )
|
|
vt = TQSizePolicy::Minimum;
|
|
}
|
|
|
|
while ( ( o = it.current() ) ) {
|
|
++it;
|
|
if ( !o->isWidgetType() || ( (TQWidget*)o )->testWState( WState_ForceHide ) )
|
|
continue;
|
|
TQWidget *w = (TQWidget*)o;
|
|
|
|
if ( w->tqsizePolicy().mayGrowHorizontally() )
|
|
ht |= TQSizePolicy::Minimum;
|
|
if ( w->tqsizePolicy().mayShrinkHorizontally() )
|
|
ht |= TQSizePolicy::Maximum;
|
|
if ( w->tqsizePolicy().mayGrowVertically() )
|
|
vt |= TQSizePolicy::Minimum;
|
|
if ( w->tqsizePolicy().mayShrinkVertically() )
|
|
vt |= TQSizePolicy::Maximum;
|
|
}
|
|
}
|
|
#ifdef USE_QT4
|
|
if ( tqlayout()->expandingDirections() & TQSizePolicy::Horizontally )
|
|
#else // USE_QT4
|
|
if ( tqlayout()->expanding() & TQSizePolicy::Horizontally )
|
|
#endif // USE_QT4
|
|
ht = TQSizePolicy::Expanding;
|
|
#ifdef USE_QT4
|
|
if ( tqlayout()->expandingDirections() & TQSizePolicy::Vertically )
|
|
#else // USE_QT4
|
|
if ( tqlayout()->expanding() & TQSizePolicy::Vertically )
|
|
#endif // USE_QT4
|
|
vt = TQSizePolicy::Expanding;
|
|
|
|
tqlayout()->tqinvalidate();
|
|
}
|
|
|
|
sp = TQSizePolicy( (TQSizePolicy::SizeType) ht, (TQSizePolicy::SizeType) vt );
|
|
updateGeometry();
|
|
}
|
|
|
|
void CustomWidget::paintEvent( TQPaintEvent *e )
|
|
{
|
|
if ( ::tqqt_cast<FormWindow*>(tqparentWidget()) ) {
|
|
( (FormWindow*)tqparentWidget() )->paintGrid( this, e );
|
|
} else {
|
|
TQPainter p( this );
|
|
p.fillRect( rect(), tqcolorGroup().dark() );
|
|
p.setPen( tqcolorGroup().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 *tqparent, const char *name ) const
|
|
{
|
|
MetaDataBase::CustomWidget *w = MetaDataBase::customWidget( WidgetDatabase::idFromClassName( className ) );
|
|
if ( !w )
|
|
return 0;
|
|
return WidgetFactory::createCustomWidget( tqparent, name, w );
|
|
}
|
|
|
|
|
|
TQDesignerToolBox::TQDesignerToolBox( TQWidget *tqparent, const char *name )
|
|
: TQToolBox( tqparent, name )
|
|
{
|
|
}
|
|
|
|
TQString TQDesignerToolBox::itemLabel() const
|
|
{
|
|
return TQToolBox::itemLabel( currentIndex() );
|
|
}
|
|
|
|
void TQDesignerToolBox::setItemLabel( const TQString &l )
|
|
{
|
|
TQToolBox::setItemLabel( currentIndex(), l );
|
|
}
|
|
|
|
TQCString TQDesignerToolBox::itemName() const
|
|
{
|
|
return currentItem() ? currentItem()->name() : 0;
|
|
}
|
|
|
|
void TQDesignerToolBox::setItemName( const TQCString &n )
|
|
{
|
|
if (currentItem())
|
|
currentItem()->setName( n );
|
|
}
|
|
|
|
|
|
TQt::BackgroundMode TQDesignerToolBox::itemBackgroundMode() const
|
|
{
|
|
return (item(0) ? item(0)->backgroundMode() : PaletteBackground);
|
|
}
|
|
|
|
void TQDesignerToolBox::setItemBackgroundMode( BackgroundMode bmode )
|
|
{
|
|
for (int i = 0; i < count(); ++i) {
|
|
TQWidget *w = item(i);
|
|
w->setBackgroundMode( bmode );
|
|
w->update();
|
|
}
|
|
}
|
|
|
|
void TQDesignerToolBox::itemInserted( int index )
|
|
{
|
|
if (count() > 1)
|
|
item(index)->setBackgroundMode(item(index>0?0:1)->backgroundMode());
|
|
}
|