public:

AddExistingDirectoriesDialog ( AutoProjectPart* part, AutoProjectWidget *widget,

SubprojectItem* spitem, TQWidget* parent = 0,

~AddExistingDirectoriesDialog();

private:

* name 'name' and widget flags set to 'f'.

*

* The dialog will by default be modeless, unless you set 'modal' to

*/

AddExistingFilesDialog::AddExistingFilesDialog ( AutoProjectPart* part, AutoProjectWidget *widget, SubprojectItem* spitem, TargetItem* titem, TQWidget* parent, const char* name, bool modal, WFlags fl )

public:

AddExistingFilesDialog( AutoProjectPart* part, AutoProjectWidget *widget,

SubprojectItem* spitem, TargetItem* titem, TQWidget* parent = 0,

~AddExistingFilesDialog();

private:

popup.setWhatsThis(idViewUIH, i18n("<b>Open ui.h file</b><p>Opens .ui.h file "

"associated with the selected .ui."));

{

popup.removeItem(idUISubclasses);

popup.removeItem(idViewUIH);

if (fitem->uiFileLink.isEmpty())

popup.removeItem(idUpdateWidgetclass);

m_part->core()->fillContextMenu( &popup, &context );

int r = popup.exec( p );

clitem = static_cast<TQCheckListItem*>(clitem->nextSibling());

}

}

TQListViewItem *item = new TQListViewItem(outsidelib_listview, *l2it);

if (lastItem)

item->moveItem(lastItem);

void CustomProjectPart::startMakeCommand( const TQString &dir, const TQString &target, bool withKdesu )

{

return; //user cancelled

TQDomDocument &dom = *projectDom();

//if there is no Makefile in the directory of the source file

//try to build it from the main build dir

//this works e.g. for non-recursive cmake Makefiles, Alex

{

buildDir = buildDirectory();

}

public:

};

#endif

public:

~RemoveSubprojectDialog();

/*$PUBLIC_FUNCTIONS$*/

bool removeFromDisk();

public:

~SubclassesDlg();

/*$PUBLIC_FUNCTIONS$*/

public:

~ChooseSubprojectDlg();

/*$PUBLIC_FUNCTIONS$*/

public:

~CreateScopeDlg();

/*$PUBLIC_FUNCTIONS$*/

class NewWidgetDlg : public NewWidgetDlgBase

{

public:

~NewWidgetDlg();

myProjectItem->updateValues( "INCLUDEPATH", values );

//target.install

{

myProjectItem->addValue( "INSTALLS", "target" );

myProjectItem->scope->setEqualOp( "target.path", TQStringList( m_InstallTargetPath->text() ) );

class ProjectConfigurationDlg : public ProjectConfigurationDlgBase

{

public:

~ProjectConfigurationDlg();

void updateControls();

void updateSubproject( QMakeScopeItem* _item );

void TrollProjectWidget::slotBuildProject()

{

return ; //user cancelled

TQString dir = projectDirectory();

void TrollProjectWidget::slotInstallProject()

{

return ; //user cancelled

TQString dir = projectDirectory();

if ( gitem->groupType == GroupItem::InstallObject )

{

// TQString relpath = m_shownSubproject->path.mid(projectDirectory().length());

TQString filepattern = KInputDialog::getText(

i18n( "Insert New Filepattern" ),

i18n( "Please enter a filepattern relative the current "

if ( gitem->groupType == GroupItem::InstallRoot )

{

// TQString relpath = m_shownSubproject->path.mid(projectDirectory().length());

TQString install_obj = KInputDialog::getText(

i18n( "Insert New Install Object" ),

i18n( "Please enter a name for the new object:" ),

}

else if ( r == idInsNewFilepatternItem )

{

TQString filepattern = KInputDialog::getText(

i18n( "Add Pattern of Files to Install" ),

i18n( "Enter a pattern relative to the current "

}

else if ( r == idInsInstallObject )

{

TQString install_obj = KInputDialog::getText(

i18n( "Add Install Object" ),

i18n( "Enter a name for the new object:" ),

{

GroupItem * titem = static_cast<GroupItem*>( item->parent() );

TQString filepattern = KInputDialog::getText(

i18n( "Edit Pattern" ),

i18n( "Enter a pattern relative to the current "

return TQAction::addTo( w );

if ( ::tqt_cast<TQPopupMenu*>(w) )

widgetToInsert->show();

addedTo( widgetToInsert, w );

}

bool QDesignerAction::removeFrom( TQWidget *w )

return TQAction::removeFrom( w );

remove();

}

void QDesignerAction::remove()

{

if ( !widgetToInsert )

return;

}

QDesignerToolBarSeparator::QDesignerToolBarSeparator(TQt::Orientation o , TQToolBar *parent,

if ( ::tqt_cast<TQToolBar*>(w) ) {

TQToolBar *tb = (TQToolBar*)w;

wid = new QDesignerToolBarSeparator( tb->orientation(), tb );

} else if ( ::tqt_cast<TQPopupMenu*>(w) ) {

idx = ( (TQPopupMenu*)w )->count();

( (TQPopupMenu*)w )->insertSeparator( idx );

}

}

bool QSeparatorAction::removeFrom( TQWidget *w )

{

if ( ::tqt_cast<TQToolBar*>(w) ) {

delete wid;

} else if ( ::tqt_cast<TQPopupMenu*>(w) ) {

( (TQPopupMenu*)w )->removeItemAt( idx );

}

}

TQWidget *QSeparatorAction::widget() const

: TQToolBar( mw ), lastIndicatorPos( -1, -1 )

{

insertAnchor = 0;

MetaDataBase::addEntry( this );

lastIndicatorPos = TQPoint( -1, -1 );

indicator = new QDesignerIndicatorWidget( this );

indicator->hide();

installEventFilter( this );

findFormWindow();

}

QDesignerToolBar::QDesignerToolBar( TQMainWindow *mw, Dock dock )

: TQToolBar( TQString(), mw, dock), lastIndicatorPos( -1, -1 )

{

insertAnchor = 0;

indicator = new QDesignerIndicatorWidget( this );

indicator->hide();

MetaDataBase::addEntry( this );

installEventFilter( this );

findFormWindow();

}

void QDesignerToolBar::findFormWindow()

if ( o == this && e->type() == TQEvent::MouseButtonPress &&

( ( TQMouseEvent*)e )->button() == TQt::LeftButton ) {

mousePressEvent( (TQMouseEvent*)e );

}

if ( o == this )

TQMouseEvent *ke = (TQMouseEvent*)e;

fixObject( o );

if ( !o )

buttonMousePressEvent( ke, o );

} else if(e->type() == TQEvent::ContextMenu ) {

TQContextMenuEvent *ce = (TQContextMenuEvent*)e;

fixObject( o );

if( !o )

buttonContextMenuEvent( ce, o );

} else if ( e->type() == TQEvent::MouseMove ) {

TQMouseEvent *ke = (TQMouseEvent*)e;

fixObject( o );

if ( !o )

buttonMouseMoveEvent( ke, o );

} else if ( e->type() == TQEvent::MouseButtonRelease ) {

TQMouseEvent *ke = (TQMouseEvent*)e;

fixObject( o );

if ( !o )

buttonMouseReleaseEvent( ke, o );

} else if ( e->type() == TQEvent::DragEnter ) {

TQDragEnterEvent *de = (TQDragEnterEvent*)e;

if (ActionDrag::canDecode(de))

void QDesignerToolBar::mousePressEvent( TQMouseEvent *e )

{

if ( e->button() == TQt::LeftButton &&

MainWindow::self->currentTool() != POINTER_TOOL &&

MainWindow::self->currentTool() != ORDER_TOOL &&

MainWindow::self->currentTool() != CONNECT_TOOL &&

MainWindow::self->currentTool() != BUDDY_TOOL )

}

void QDesignerToolBar::mouseReleaseEvent( TQMouseEvent *e )

{

if ( widgetInserting )

doInsertWidget( mapFromGlobal( e->globalPos() ) );

}

void QDesignerToolBar::buttonMouseReleaseEvent( TQMouseEvent *e, TQObject *w )

if ( widgetInserting )

doInsertWidget( mapFromGlobal( e->globalPos() ) );

else if ( w->isWidgetType() && formWindow->widgets()->find( w ) ) {

formWindow->selectWidget( w );

}

}

void QDesignerToolBar::buttonContextMenuEvent( TQContextMenuEvent *e, TQObject *o )

void QDesignerToolBar::buttonMousePressEvent( TQMouseEvent *e, TQObject * )

{

if ( e->button() == TQt::MidButton )

return;

MainWindow::self->currentTool() != ORDER_TOOL &&

MainWindow::self->currentTool() != CONNECT_TOOL &&

MainWindow::self->currentTool() != BUDDY_TOOL ) {

return;

}

drag->setPixmap( a->iconSet().pixmap() );

if ( ::tqt_cast<QDesignerAction*>(a) ) {

if ( formWindow->widgets()->find( ( (QDesignerAction*)a )->widget() ) )

}

if ( !drag->drag() ) {

AddActionToToolBarCommand *cmd = new AddActionToToolBarCommand( i18n( "Add Action '%1' to Toolbar '%2'" ).

void QDesignerToolBar::dragEnterEvent( TQDragEnterEvent *e )

{

lastIndicatorPos = TQPoint( -1, -1 );

if (ActionDrag::canDecode(e))

e->accept();

{

indicator->hide();

insertAnchor = 0;

}

void QDesignerToolBar::dropEvent( TQDropEvent *e )

if ( orientation() ==TQt::Horizontal ) {

TQPoint pnt( width() - 2, 0 );

insertAnchor = 0;

TQObjectList clo = childrenListObject();

if ( clo.isEmpty() )

return pnt;

if ( w->x() < pos.x() ) {

pnt.setX( w->x() + w->width() + 1 );

insertAnchor = w;

}

}

}

} else {

TQPoint pnt( 0, height() - 2 );

insertAnchor = 0;

TQObjectList clo = childrenListObject();

if ( clo.isEmpty() )

return pnt;

if ( w->y() < pos.y() ) {

pnt.setY( w->y() + w->height() + 1 );

insertAnchor = w;

}

}

}

if ( formWindow != MainWindow::self->formWindow() )

return;

calcIndicatorPos( p );

installEventFilters( w );

QDesignerAction *a = new QDesignerAction( w, parent() );

int index = actionList.findRef( *actionMap.find( insertAnchor ) );

if ( index != -1 && afterAnchor )

explicitlyClosed(false)

{

listActions->addColumn( i18n( "Actions" ) );

TQPopupMenu *popup = new TQPopupMenu( this );

popup->insertItem( i18n( "New &Action" ), this, TQ_SLOT( newAction() ) );

TQAction *ActionEditor::newActionEx()

{

TQAction *a = i->action();

TQObject::connect( a, TQ_SIGNAL( destroyed( TQObject * ) ),

this, TQ_SLOT( removeConnections( TQObject* ) ) );

MetaDataBase::addEntry( i->action() );

TQString n = "Action";

i->setText( 0, n );

i->action()->setName( n );

i->action()->setText( i->action()->name() );

formWindow->actionList().append( i->action() );

if ( formWindow->formFile() )

return i->action();

}

if ( formWindow ) {

formWindow->setActiveObject( formWindow->mainContainer() );

if ( formWindow->formFile() )

}

}

if ( actionParent )

i = new ActionItem( actionParent );

else

TQAction *a = i->action();

TQObject::connect( a, TQ_SIGNAL( destroyed( TQObject * ) ),

this, TQ_SLOT( removeConnections( TQObject* ) ) );

MetaDataBase::addEntry( i->action() );

TQString n = "Action";

i->setText( 0, n );

i->action()->setName( n );

i->action()->setText( i->action()->name() );

if ( actionParent && actionParent->actionGroup() &&

actionParent->actionGroup()->usesDropDown() ) {

}

listActions->setCurrentItem( i );

if ( !actionParent )

formWindow->actionList().append( i->action() );

if ( formWindow->formFile() )

}

void ActionEditor::newActionGroup()

ActionItem *i = 0;

if ( actionParent )

else

TQAction *ag = i->actionGroup();

TQObject::connect( ag, TQ_SIGNAL( destroyed( TQObject * ) ),

this, TQ_SLOT( removeConnections( TQObject* ) ) );

MetaDataBase::addEntry( i->actionGroup() );

TQString n = "ActionGroup";

i->setText( 0, n );

i->actionGroup()->setName( n );

i->actionGroup()->setText( i->actionGroup()->name() );

listActions->setCurrentItem( i );

if ( !actionParent )

formWindow->actionList().append( i->actionGroup() );

if ( formWindow->formFile() )

}

void ActionEditor::newDropDownActionGroup()

{

newActionGroup();

}

void ActionEditor::setFormWindow( FormWindow *fw )

formWindow = fw;

if ( !formWindow ||

!::tqt_cast<TQMainWindow*>(formWindow->mainContainer()) ) {

} else {

for ( TQAction *a = formWindow->actionList().first(); a; a = formWindow->actionList().next() ) {

ActionItem *i = 0;

if ( ::tqt_cast<TQAction*>(a->parent()) )

}

if ( listActions->firstChild() ) {

listActions->setCurrentItem( listActions->firstChild() );

}

}

}

continue;

TQAction *a = (TQAction*)o;

ActionItem *i2 = new ActionItem( (TQListViewItem*)i, a );

i2->setText( 0, a->name() );

i2->setPixmap( 0, a->iconSet().pixmap() );

// make sure we don't duplicate the connection

ActionListView::ActionListView( TQWidget *parent, const char *name )

: TQListView( parent, name )

{

setResizeMode( LastColumn );

connect( this, TQ_SIGNAL( contextMenuRequested( TQListViewItem *, const TQPoint &, int ) ),

this, TQ_SLOT( rmbMenu( TQListViewItem *, const TQPoint & ) ) );

}

g = ::tqt_cast<QDesignerActionGroup*>(ac);

if ( !g )

a = ::tqt_cast<QDesignerAction*>(ac);

}

ActionItem::ActionItem( TQListViewItem *i, TQAction *ac )

g = ::tqt_cast<QDesignerActionGroup*>(ac);

if ( !g )

a = ::tqt_cast<QDesignerAction*>(ac);

moveToEnd();

}

ActionItem( TQListView *lv, bool group )

: TQListViewItem( lv ),

a( group ? 0 : new QDesignerAction( 0 ) ),

ActionItem( TQListView *lv, TQAction *ac );

ActionItem( TQListViewItem *i, TQAction *ac );

: TQListViewItem( parent ),

a( group ? 0 : new QDesignerAction( parent->actionGroup() ) ),

QDesignerAction *action() const { return a; }

QDesignerActionGroup *actionGroup() const { return g; }

#include <tqstring.h>

AsciiValidator::AsciiValidator( TQObject * parent, const char *name )

{

}

}

AsciiValidator::AsciiValidator( const TQString &allow, TQObject * parent, const char *name )

{

}

TQValidator::State AsciiValidator::validate( TQString &s, int & ) const

{

if ( !s.isEmpty() && s[0].row() == 0 && s[0].cell() >= '0' && s[0].cell() <= '9' )

s[0] = '_';

for ( int i = 0, j = 0; i < (int) s.length(); i++ ) {

if ( functionName ) {

if ( c == '(' ) {

continue;

}

if ( c == ')' ) {

j = i + 1;

continue;

}

CommandHistory::CommandHistory( int s )

: current( -1 ), steps( s ), savedAt( -1 )

{

compressedCommand = 0;

}

if ( compressedCommand ) {

compressedCommand->merge( cmd );

modificationChanged( modified );

return;

}

savedAt = -2;

TQPtrList<Command> commands;

for( int i = 0; i <= current; ++i ) {

commands.insert( i, history.at( 0 ) );

commands.append( cmd );

history.clear();

history = commands;

} else {

history.append( cmd );

}

}

emitUndoRedo();

modificationChanged( modified );

}

bool Command::canMerge( Command * )

{

}

// ------------------------------------------------------------

}

widget->show();

formWindow()->widgets()->insert( widget, widget );

formWindow()->selectWidget( widget );

formWindow()->mainWindow()->objectHierarchy()->widgetInserted( widget );

}

void InsertCommand::unexecute()

{

widget->hide();

formWindow()->widgets()->remove( widget );

formWindow()->mainWindow()->objectHierarchy()->widgetRemoved( widget );

}

: Command( n, fw ), widgets( w ), oldPos( op ), newPos( np ),

oldParent( opr ), newParent( npr )

{

}

void MoveCommand::merge( Command *c )

if ( !w->parentWidget() || WidgetFactory::layoutType( w->parentWidget() ) == WidgetFactory::NoLayout ) {

if ( newParent && oldParent && newParent != oldParent ) {

TQPoint pos = newParent->mapFromGlobal( w->mapToGlobal( TQPoint( 0,0 ) ) );

formWindow()->raiseSelection( w );

formWindow()->raiseChildSelections( w );

formWindow()->widgetChanged( w );

if ( !w->parentWidget() || WidgetFactory::layoutType( w->parentWidget() ) == WidgetFactory::NoLayout ) {

if ( newParent && oldParent && newParent != oldParent ) {

TQPoint pos = oldParent->mapFromGlobal( w->mapToGlobal( TQPoint( 0,0 ) ) );

formWindow()->raiseSelection( w );

formWindow()->raiseChildSelections( w );

formWindow()->widgetChanged( w );

const TQWidgetList &wl )

: Command( n, fw ), widgets( wl )

{

TQWidgetList copyOfWidgets = widgets;

// Include the children of the selected items when deleting

for ( TQWidget *w = widgets.first(); w; w = widgets.next() ) {

void DeleteCommand::execute()

{

connections.clear();

for ( TQWidget *w = widgets.first(); w; w = widgets.next() ) {

w->hide();

TQString s = w->name();

s.prepend( "qt_dead_widget_" );

w->setName( s );

formWindow()->widgets()->remove( w );

TQValueList<MetaDataBase::Connection> conns = MetaDataBase::connections( formWindow(), w );

connections.insert( w, conns );

(*it).signal, (*it).receiver, (*it).slot );

}

}

formWindow()->emitShowProperties();

formWindow()->mainWindow()->objectHierarchy()->widgetsRemoved( widgets );

void DeleteCommand::unexecute()

{

for ( TQWidget *w = widgets.first(); w; w = widgets.next() ) {

w->show();

TQString s = w->name();

(*it).signal, (*it).receiver, (*it).slot );

}

}

formWindow()->emitShowProperties();

formWindow()->mainWindow()->objectHierarchy()->widgetsInserted( widgets );

}

const TQString &ocut, bool reset )

: Command( n, fw ), widget( w ), editor( e ), propName( pn ),

oldValue( ov ), newValue( nv ), oldCurrentItemText( ocut ), newCurrentItemText( ncut ),

{

wasChanged = MetaDataBase::isPropertyChanged( w, propName );

if ( oldCurrentItemText.isNull() )

void SetPropertyCommand::execute()

{

if ( !wasChanged )

if ( isResetCommand ) {

if ( WidgetFactory::resetProperty( widget, propName ) ) {

if ( !formWindow()->isWidgetSelected( widget ) && formWindow() != widget )

formWindow()->selectWidget( widget );

if ( !i )

return;

i->setValue( widget->property( propName ) );

editor->refetchData();

editor->emitWidgetChanged();

return;

void SetPropertyCommand::unexecute()

{

if ( !wasChanged )

if ( isResetCommand )

setProperty( oldValue, oldCurrentItemText );

}

{

SetPropertyCommand *cmd = (SetPropertyCommand*)c;

if ( !widget )

const TQMetaProperty *p =

if ( !p ) {

if ( propName == "toolTip" || propName == "whatsThis" )

if ( ::tqt_cast<CustomWidget*>((TQObject *)widget) ) {

MetaDataBase::CustomWidget *cw = ((CustomWidget*)(TQObject*)widget)->customWidget();

if ( !cw )

for ( TQValueList<MetaDataBase::Property>::Iterator it = cw->lstProperties.begin(); it != cw->lstProperties.end(); ++it ) {

if ( TQString( (*it ).property ) == propName ) {

if ( (*it).type == "String" || (*it).type == "CString" || (*it).type == "Int" || (*it).type == "UInt" )

}

}

}

}

TQVariant::Type t = TQVariant::nameToType( p->type() );

return ( cmd->propName == propName &&

{

if ( propName == "name" /*|| propName == "itemName"*/ ) { // ### fix that

TQString s = newValue.toString();

TQMessageBox::information( formWindow()->mainWindow(),

i18n( "Set 'name' Property" ),

i18n( "The name of a widget must be unique.\n"

arg( newValue.toString() ).

arg( formWindow()->name() ).

arg( oldValue.toString() ));

}

if ( s.isEmpty() ) {

TQMessageBox::information( formWindow()->mainWindow(),

i18n( "The name of a widget must not be null.\n"

"The name has been reverted to '%1'." ).

arg( oldValue.toString() ));

}

if ( ::tqt_cast<FormWindow*>(widget->parent()) )

formWindow()->mainWindow()->formNameChanged( (FormWindow*)((TQWidget*)(TQObject*)widget)->parentWidget() );

}

}

void SetPropertyCommand::setProperty( const TQVariant &v, const TQString &currentItemText, bool select )

if ( select )

editor->propertyList()->setCurrentProperty( propName );

const TQMetaProperty *p =

if ( !p ) {

if ( propName == "hAlign" ) {

int align = widget->property( "alignment" ).toInt();

align &= ~( AlignHorizontal_Mask );

align |= p->keyToValue( currentItemText );

widget->setProperty( "alignment", TQVariant( align ) );

} else if ( propName == "vAlign" ) {

int align = widget->property( "alignment" ).toInt();

align &= ~( AlignVertical_Mask );

align |= p->keyToValue( currentItemText );

void LayoutHorizontalCommand::execute()

{

layout.doLayout();

formWindow()->mainWindow()->objectHierarchy()->rebuild();

}

void LayoutHorizontalCommand::unexecute()

{

layout.undoLayout();

formWindow()->mainWindow()->objectHierarchy()->rebuild();

}

LayoutHorizontalSplitCommand::LayoutHorizontalSplitCommand( const TQString &n, FormWindow *fw,

TQWidget *parent, TQWidget *layoutBase,

const TQWidgetList &wl )

{

}

void LayoutHorizontalSplitCommand::execute()

{

layout.doLayout();

formWindow()->mainWindow()->objectHierarchy()->rebuild();

}

void LayoutHorizontalSplitCommand::unexecute()

{

layout.undoLayout();

formWindow()->mainWindow()->objectHierarchy()->rebuild();

}

void LayoutVerticalCommand::execute()

{

layout.doLayout();

formWindow()->mainWindow()->objectHierarchy()->rebuild();

}

void LayoutVerticalCommand::unexecute()

{

layout.undoLayout();

formWindow()->mainWindow()->objectHierarchy()->rebuild();

}

LayoutVerticalSplitCommand::LayoutVerticalSplitCommand( const TQString &n, FormWindow *fw,

TQWidget *parent, TQWidget *layoutBase,

const TQWidgetList &wl )

{

}

void LayoutVerticalSplitCommand::execute()

{

layout.doLayout();

formWindow()->mainWindow()->objectHierarchy()->rebuild();

}

void LayoutVerticalSplitCommand::unexecute()

{

layout.undoLayout();

formWindow()->mainWindow()->objectHierarchy()->rebuild();

}

void LayoutGridCommand::execute()

{

layout.doLayout();

formWindow()->mainWindow()->objectHierarchy()->rebuild();

}

void LayoutGridCommand::unexecute()

{

layout.undoLayout();

formWindow()->mainWindow()->objectHierarchy()->rebuild();

}

margin = MetaDataBase::margin( layoutBase );

layout = 0;

if ( lay == WidgetFactory::HBox )

else if ( lay == WidgetFactory::VBox )

else if ( lay == WidgetFactory::Grid )

}

void BreakLayoutCommand::execute()

{

if ( !layout )

return;

layout->breakLayout();

formWindow()->mainWindow()->objectHierarchy()->rebuild();

for ( TQWidget *w = widgets.first(); w; w = widgets.next() )

{

if ( !layout )

return;

layout->doLayout();

formWindow()->mainWindow()->objectHierarchy()->rebuild();

MetaDataBase::setSpacing( WidgetFactory::containerOfWidget( lb ), spacing );

formWindow()->mainWindow()->part()->emitAddedFunction(formWindow()->fileName(), f);

if ( formWindow()->formFile() )

}

void AddFunctionCommand::unexecute()

formWindow()->mainWindow()->part()->emitRemovedFunction(formWindow()->fileName(), f);

if ( formWindow()->formFile() )

}

// ------------------------------------------------------------

formWindow()->mainWindow()->part()->emitEditedFunction(formWindow()->fileName(), of, f);

if ( formWindow()->formFile() )

}

void ChangeFunctionAttribCommand::unexecute()

formWindow()->mainWindow()->part()->emitEditedFunction(formWindow()->fileName(), f, of);

if ( formWindow()->formFile() )

}

// ------------------------------------------------------------

formWindow()->mainWindow()->part()->emitRemovedFunction(formWindow()->fileName(), f);

if ( formWindow()->formFile() )

}

void RemoveFunctionCommand::unexecute()

formWindow()->mainWindow()->part()->emitAddedFunction(formWindow()->fileName(), f);

if ( formWindow()->formFile() )

}

// ------------------------------------------------------------

MetaDataBase::addVariable( formWindow(), varName, access );

formWindow()->mainWindow()->objectHierarchy()->updateFormDefinitionView();

if ( formWindow()->formFile() )

}

void AddVariableCommand::unexecute()

MetaDataBase::removeVariable( formWindow(), varName );

formWindow()->mainWindow()->objectHierarchy()->updateFormDefinitionView();

if ( formWindow()->formFile() )

}

// ------------------------------------------------------------

MetaDataBase::setVariables( formWindow(), newList );

formWindow()->mainWindow()->objectHierarchy()->updateFormDefinitionView();

if ( formWindow()->formFile() )

}

void SetVariablesCommand::unexecute()

MetaDataBase::setVariables( formWindow(), oldList );

formWindow()->mainWindow()->objectHierarchy()->updateFormDefinitionView();

if ( formWindow()->formFile() )

}

// ------------------------------------------------------------

MetaDataBase::removeVariable( formWindow(), varName );

formWindow()->mainWindow()->objectHierarchy()->updateFormDefinitionView();

if ( formWindow()->formFile() )

}

void RemoveVariableCommand::unexecute()

MetaDataBase::addVariable( formWindow(), varName, access );

formWindow()->mainWindow()->objectHierarchy()->updateFormDefinitionView();

if ( formWindow()->formFile() )

}

// ------------------------------------------------------------

lIface->release();

formWindow()->mainWindow()->objectHierarchy()->updateFormDefinitionView();

if ( formWindow()->formFile() )

}

void EditDefinitionsCommand::unexecute()

lIface->release();

formWindow()->mainWindow()->objectHierarchy()->updateFormDefinitionView();

if ( formWindow()->formFile() )

}

// ------------------------------------------------------------

{

for ( TQWidget *w = widgets.first(); w; w = widgets.next() ) {

w->hide();

formWindow()->widgets()->remove( w );

formWindow()->mainWindow()->objectHierarchy()->widgetRemoved( w );

}

bool TabOrderCommand::canMerge( Command * )

{

}

void TabOrderCommand::execute()

toLasts.pop();

toLasts.push( ni );

if ( pi )

} else {

if ( i->parent() == fromLast ) {

fromParents.push( fromLast );

toLasts.pop();

toLasts.push( ni );

if ( pi )

} else {

while ( fromParents.top() != i->parent() ) {

fromParents.pop();

ni->setPixmap( c, *i->pixmap( c ) );

}

if ( pi )

toLasts.pop();

toLasts.push( ni );

}

void PopulateMultiLineEditCommand::execute()

{

mlined->setText( newText );

formWindow()->emitUpdateProperties( mlined );

}

if ( !toolBar ) {

toolBar = new QDesignerToolBar( mainWindow );

TQString n = "Toolbar";

toolBar->setName( n );

mainWindow->addToolBar( toolBar, n );

} else {

ActionEditor *ae = actionEditor();

if ( ae )

ae->updateActionIcon( action );

}

void SetActionIconsCommand::unexecute()

ActionEditor *ae = actionEditor();

if ( ae )

ae->updateActionIcon( action );

}

// ------------------------------------------------------------

if ( !mb ) {

mb = new MenuBarEditor( formWindow(), mw );

mb->setName( "MenuBarEditor" );

}

if ( !item ) {

PopupMenuEditor *popup = new PopupMenuEditor( formWindow(), mw );

popup->setName( "PopupMenuEditor" );

mb->insertItem( name, popup, index );

index = mb->findItem( popup );

item = mb->item( index );

} else {

PopupMenuEditor *popup = item->menu();

popup->setName( item->menuText() );

mb->insertItem( item, index );

}

formWindow()->mainWindow()->objectHierarchy()->rebuild();

PopupMenuEditor *popup = item->menu();

item->setMenuText( newName );

TQString legal = makeLegal( newName );

popup->setName( legal );

formWindow()->mainWindow()->objectHierarchy()->rebuild();

}

public:

CommandHistory( int s );

void undo();

void redo();

const TQString &pn, const TQVariant &ov,

const TQVariant &nv, const TQString &ncut,

const TQString &ocut,

void execute();

void unexecute();

bool checkProperty();

private:

TQGuardedPtr<TQObject> widget;

PropertyEditor *editor;

{

public:

AddWizardPageCommand( const TQString &n, FormWindow *fw,

void execute();

void unexecute();

{

public:

DeleteWizardPageCommand( const TQString &n, FormWindow *fw,

void execute();

void unexecute();

if ( !parent ) {

parent = new TQListViewItem( listViewTools );

parent->setText( 0, grp );

groups.insert( grp, parent );

}

TQListViewItem *i = new TQListViewItem( parent );

{

TQListView *src = listViewTools;

TQListViewItem *nextSibling = 0;

TQListViewItem *nextParent = 0;

TQListViewItemIterator it = src->firstChild();

for ( ; *it; it++ ) {

// Hit the nextSibling, turn of child processing

if ( (*it) == nextSibling )

if ( (*it)->isSelected() ) {

if ( (*it)->childCount() == 0 ) {

// Children processing not set, so set it

// Also find the item were we shall quit

// processing children...if any such item

nextSibling = (*it)->nextSibling();

nextParent = (*it)->parent();

while ( nextParent && !nextSibling ) {

void ConfigToolboxDialog::currentToolChanged( TQListViewItem *i )

{

TQListViewItemIterator it = listViewTools->firstChild();

for ( ; *it; it++ ) {

if ( (*it)->isSelected() ) {

break;

}

}

buttonUp->setEnabled( (bool) (i && i->itemAbove()) );

buttonDown->setEnabled( (bool) (i && i->itemBelow()) );

TQListViewItemIterator it = listViewCommon->firstChild();

for ( ; *it; it++ ) {

if ( (*it)->isSelected() ) {

break;

}

}

this, TQ_SLOT( updateEditSlotsButton() ) );

connect( connectionsTable, TQ_SIGNAL( resorted() ),

this, TQ_SLOT( updateConnectionContainers() ) );

if ( !invalidConnection ) {

invalidConnection = new TQPixmap( invalid_connection );

it != conns.end(); ++it ) {

ConnectionContainer *c = addConnection( (*it).sender, (*it).receiver,

(*it).signal, (*it).slot );

updateConnectionState( c );

}

sl->setCurrentItem( slot );

}

return c;

}

void ConnectionDialog::editSlots()

{

dlg.exec();

int currentCol = connectionsTable->currentColumn();

connectionsTable->setCurrentCell( connectionsTable->currentRow(), 0 );

};

ConnectionItem::ConnectionItem( TQTable *table, FormWindow *fw )

{

}

void ConnectionItem::senderChanged( TQObject * )

TQFont f( p->font() );

TQFont oldf( p->font() );

if ( conn && conn->isModified() ) {

p->setFont( f );

}

void SignalItem::senderChanged( TQObject *sender )

{

sigs.remove( "destroyed()" );

sigs.remove( "destroyed(TQObject*)" );

sigs.remove( "accessibilityChanged(int)" );

#ifndef TQT_NO_SQL

if ( qstrcmp( slot, "update()" ) == 0 &&

::tqt_cast<TQDataBrowser*>(lastReceiver) )

#endif

for ( int i = 0; ignore_slots[i]; i++ ) {

if ( qstrcmp( slot, ignore_slots[i] ) == 0 )

}

if ( !formWindow->isMainContainer( lastReceiver ) ) {

if ( qstrcmp( slot, "close()" ) == 0 )

}

if ( qstrcmp( slot, "setFocus()" ) == 0 )

if ( lastReceiver->isWidgetType() &&

( (TQWidget*)lastReceiver )->focusPolicy() == TQWidget::NoFocus )

}

void SlotItem::updateSlotList()

}

TQString signal = MetaDataBase::normalizeFunction( lastSignal );

TQStringList slts;

for( int i = 0; i < n; ++i ) {

// accept only public slots. For the form window, also accept protected slots

(formWindow->isMainContainer( lastReceiver ) &&

TQMetaData::Protected) ) &&

!ignoreSlot( md->name ) &&

checkConnectArgs( signal.latin1(), lastReceiver, md->name ) )

public:

ConnectionContainer( TQObject *parent, SenderItem *i1, SignalItem *i2,

ReceiverItem *i3, SlotItem *i4, int r )

re( i3 ), sl( i4 ), rw ( r ) {

i1->setConnection( this );

i2->setConnection( this );

SlotItem *slotItem() const { return sl; }

public slots:

signals:

void changed( ConnectionContainer *c );

ConnectionTable::ConnectionTable( TQWidget *parent, const char *name )

: TQTable( 0, 4, parent, name )

{

setFocusStyle( FollowStyle );

setSelectionMode( SingleRow );

horizontalHeader()->setLabel( 0, i18n( "Sender" ) );

horizontalHeader()->setLabel( 1, i18n( "Signal" ) );

horizontalHeader()->setLabel( 2, i18n( "Receiver" ) );

horizontalHeader()->setLabel( 3, i18n( "Slot" ) );

}

void ConnectionTable::sortColumn( int col, bool ascending, bool )

{

horizontalHeader()->setSortIndicator( col, ascending );

if ( isEditing() )

setCurrentCell( 0, 0 );

emit resorted();

}

#include <tdelocale.h>

CustomWidgetEditor::CustomWidgetEditor( TQWidget *parent, MainWindow *mw )

{

connect( helpButton, TQ_SIGNAL( clicked() ), MainWindow::self, TQ_SLOT( showDialogHelp() ) );

checkTimer = new TQTimer( this );

connect( checkTimer, TQ_SIGNAL( timeout() ),

this, TQ_SLOT( checkWidgetName() ) );

editClass->setValidator( new AsciiValidator( TQString(":"), editClass ) );

editProperty->setValidator( new AsciiValidator( editSignal ) );

setupDefinition();

setupSignals();

if ( boxWidgets->firstItem() ) {

boxWidgets->setCurrentItem( boxWidgets->firstItem() );

}

oldItem = 0;

}

void CustomWidgetEditor::setupSignals()

{

MetaDataBase::CustomWidget *w = findWidget( boxWidgets->item( boxWidgets->currentItem() ) );

if ( !w )

return;

listSignals->insertItem( TQString( *it ) );

if ( listSignals->firstItem() ) {

listSignals->setCurrentItem( listSignals->firstItem() );

}

}

void CustomWidgetEditor::setupSlots()

{

MetaDataBase::CustomWidget *w = findWidget( boxWidgets->item( boxWidgets->currentItem() ) );

if ( !w )

if ( listSlots->firstChild() ) {

listSlots->setCurrentItem( listSlots->firstChild() );

}

}

void CustomWidgetEditor::setupProperties()

{

MetaDataBase::CustomWidget *w = findWidget( boxWidgets->item( boxWidgets->currentItem() ) );

if ( !w )

if ( listProperties->firstChild() ) {

listProperties->setCurrentItem( listProperties->firstChild() );

}

}

MetaDataBase::CustomWidget *w = findWidget( i );

if ( !i || !w ) {

return;

}

editClass->setText( w->className );

editHeader->setText( w->includeFile );

localGlobalCombo->setCurrentItem( (int)w->includePolicy );

if ( w->pixmap )

customWidgets.insert( i, w );

boxWidgets->setCurrentItem( i );

}

void CustomWidgetEditor::classNameChanged( const TQString &s )

WidgetDatabase::customWidgetClassNameChanged( w->className, s );

checkTimer->stop();

oldName = w->className;

w->className = s;

TQListBoxItem *old = i;

oldItem = i;

customWidgets.insert( i, w );

customWidgets.remove( old );

}

void CustomWidgetEditor::deleteWidgetClicked()

i = boxWidgets->item( boxWidgets->currentItem() );

if ( i ) {

boxWidgets->setCurrentItem( i );

}

}

delete w->pixmap;

w->pixmap = new TQPixmap( pix );

TQListBoxItem *old = i;

boxWidgets->changeItem( *w->pixmap, w->className, boxWidgets->currentItem() );

i = boxWidgets->item( boxWidgets->currentItem() );

customWidgets.insert( i, w );

customWidgets.remove( old );

previewPixmap->setPixmap( *w->pixmap );

}

void CustomWidgetEditor::currentSignalChanged( TQListBoxItem *i )

{

editSignal->setText( "" );

if ( !i ) {

return;

}

editSignal->setText( i->text() );

}

void CustomWidgetEditor::addSignal()

{

TQListBoxItem *i = new TQListBoxText( listSignals, "signal()" );

listSignals->setCurrentItem( i );

MetaDataBase::CustomWidget *w = findWidget( boxWidgets->item( boxWidgets->currentItem() ) );

if ( w )

w->lstSignals.append( i->text().latin1() );

TQString s = listSignals->currentText();

delete listSignals->item( listSignals->currentItem() );

if ( listSignals->currentItem() != -1 )

MetaDataBase::CustomWidget *w = findWidget( boxWidgets->item( boxWidgets->currentItem() ) );

if ( w )

w->lstSignals.remove( s.latin1() );

TQValueList<TQCString>::Iterator it = w->lstSignals.find( listSignals->currentText().latin1() );

if ( it != w->lstSignals.end() )

w->lstSignals.remove( it );

listSignals->changeItem( s, listSignals->currentItem() );

w->lstSignals.append( s.latin1() );

}

{

TQListViewItem *i = new TQListViewItem( listSlots, "slot()", "public" );

listSlots->setCurrentItem( i );

MetaDataBase::CustomWidget *w = findWidget( boxWidgets->item( boxWidgets->currentItem() ) );

if ( w ) {

MetaDataBase::Function slot;

}

delete listSlots->currentItem();

if ( listSlots->currentItem() )

MetaDataBase::CustomWidget *w = findWidget( boxWidgets->item( boxWidgets->currentItem() ) );

if ( w && slot.function != "1 2 3" )

w->lstSlots.remove( slot );

void CustomWidgetEditor::currentSlotChanged( TQListViewItem *i )

{

editSlot->setText( "" );

if ( !i ) {

return;

}

editSlot->setText( i->text( 0 ) );

if ( i->text( 1 ) == i18n( "protected" ) )

comboAccess->setCurrentItem( 1 );

else

comboAccess->setCurrentItem( 0 );

}

void CustomWidgetEditor::propertyTypeChanged( const TQString &s )

{

TQListViewItem *i = new TQListViewItem( listProperties, "property", "String" );

listProperties->setCurrentItem( i );

MetaDataBase::CustomWidget *w = findWidget( boxWidgets->item( boxWidgets->currentItem() ) );

if ( w ) {

MetaDataBase::Property prop;

}

delete listProperties->currentItem();

if ( listProperties->currentItem() )

MetaDataBase::CustomWidget *w = findWidget( boxWidgets->item( boxWidgets->currentItem() ) );

if ( w && property.property != "1 2 3" )

w->lstProperties.remove( property );

void CustomWidgetEditor::currentPropertyChanged( TQListViewItem *i )

{

editProperty->setText( "" );

if ( !i ) {

return;

}

editProperty->setText( i->text( 0 ) );

for ( int j = 0; j < comboType->count(); ++j ) {

break;

}

}

}

static TQString makeIndent2( int indent )

#endif

if ( e->type() == TQEvent::Show ) {

if ( con ) {

setForm( frm );

refresh();

first();

}

}

#if defined(DESIGNER)

}

if ( e->type() == TQEvent::Show ) {

setForm( frm );

readFields();

}

#if defined(DESIGNER)

}

void DatabaseConnectionEditor::init()

{

connectionWidget->editName->setValidator( new AsciiValidator( connectionWidget->editName ) );

connectionWidget->editName->setText( conn->name() );

connectionWidget->comboDriver->lineEdit()->setText( conn->driver() );

connectionWidget->editDatabase->setText( conn->database() );

connectionWidget->editUsername->setText( conn->username() );

connectionWidget->editPassword->setText( "" );

connectionWidget->editHostname->setText( conn->hostname() );

connectionWidget->editPort->setValue( conn->port() );

connectionWidget->editUsername->setFocus();

connectionWidget->editUsername->selectAll();

public:

DatabaseConnectionEditor( DatabaseConnection* connection, TQWidget* parent = 0,

~DatabaseConnectionEditor();

public slots:

#include <tdelocale.h>

/*

* Constructs a DatabaseConnectionsEditor which is a child of 'parent', with the

* name 'name' and widget flags set to 'f'

*

* The dialog will by default be modeless, unless you set 'modal' to

*/

DatabaseConnectionsEditor::DatabaseConnectionsEditor( Project *pro, TQWidget* parent, const char* name, bool modal, WFlags fl )

: DatabaseConnectionBase( parent, name, modal, fl ), project( pro )

connectionWidget->comboDriver->insertStringList( TQSqlDatabase::drivers() );

#endif

connectionWidget->editName->setValidator( new AsciiValidator( connectionWidget->editName ) );

}

DatabaseConnectionsEditor::~DatabaseConnectionsEditor()

listConnections->setCurrentItem( 0 );

currentConnectionChanged( listConnections->currentText() );

} else {

}

project->saveConnections();

}

void DatabaseConnectionsEditor::newConnection()

{

TQString n( "(default)" );

if ( project->databaseConnection( n ) ) {

n = "connection";

}

connectionWidget->editName->setText( n );

listConnections->clearSelection();

connectionWidget->editName->setFocus();

}

void DatabaseConnectionsEditor::doConnect()

{

#ifndef TQT_NO_SQL

DatabaseConnection *conn = project->databaseConnection( s );

enableAll( conn != 0 );

if ( !conn )

return;

connectionWidget->editName->setText( conn->name() );

connectionWidget->comboDriver->lineEdit()->setText( conn->driver() );

connectionWidget->editDatabase->setText( conn->database() );

connectionWidget->editUsername->setText( conn->username() );

public:

DatabaseConnectionsEditor( Project *pro, TQWidget* parent = 0,

~DatabaseConnectionsEditor();

protected slots:

:TQAction(menuText, accel, parent, name) {}

DesignerAction ( const TQIconSet & icon, const TQString & menuText, TQKeySequence accel, TQObject * parent, const char * name = 0 )

:TQAction(icon, menuText, accel, parent, name) {}

:TQAction(text, icon, menuText, accel, parent, name, toggle) {}

:TQAction(text, menuText, accel, parent, name, toggle) {}

DesignerAction ( TQObject * parent, const char * name, bool toggle )

:TQAction(parent, name, toggle) {}

TQRect mainRect;

TQString keybase = settingsKey();

mainRect.setX( config.readNumEntry( keybase + "Geometries/MainwindowX", 0 ) );

mainRect.setY( config.readNumEntry( keybase + "Geometries/MainwindowY", 0 ) );

mainRect.setWidth( config.readNumEntry( keybase + "Geometries/MainwindowWidth", 500 ) );

TQObjectList* l = MainWindow::self->queryList( "FormWindow" );

FormWindow* fw = (FormWindow*) l->first();

FormWindow* totop = 0;

while ( fw ) {

haveit = haveit || fw->fileName() == arg;

if ( haveit )

}

if ( !haveit ) {

MainWindow::self->openFormWindow( arg );

} else if ( totop ) {

totop->setFocus();

delete l;

}

}

}

return TQApplication::winEventFilter( msg );

}

TQWidget *DesignerFormWindowImpl::create( const char *className, TQWidget *parent, const char *name )

{

TQWidget *w = WidgetFactory::create( WidgetDatabase::idFromClassName( className ), parent, name );

formWindow->killAccels( formWindow->mainContainer() );

return w;

}

void DesignerFormWindowImpl::selectWidget( TQWidget * w )

{

}

void DesignerFormWindowImpl::selectAll()

bool DesignerFormWindowImpl::isWidgetSelected( TQWidget * ) const

{

}

TQWidgetList DesignerFormWindowImpl::selectedWidgets() const

return;

formWindow->actionList().append( a );

MetaDataBase::addEntry( a );

if ( !a->iconSet().isNull() && !a->iconSet().pixmap().isNull() )

}

void DesignerFormWindowImpl::removeAction( TQAction *a )

void DesignerFormWindowImpl::setProperty( TQObject *o, const char *property, const TQVariant &value )

{

if ( p && p->isValid() )

o->setProperty( property, value );

else

TQVariant DesignerFormWindowImpl::property( TQObject *o, const char *prop ) const

{

if ( p && p->isValid() )

return o->property( prop );

return MetaDataBase::fakeProperty( o, prop );

TQMainWindow *mw = (TQMainWindow*)formWindow->mainContainer();

PopupMenuEditor *popup = new PopupMenuEditor( formWindow, mw );

TQString n = name;

popup->setName( n );

MenuBarEditor *mb = (MenuBarEditor *)mw->child( 0, "MenuBarEditor" );

if ( !mb ) {

TQMainWindow *mw = (TQMainWindow*)formWindow->mainContainer();

TQToolBar *tb = new QDesignerToolBar( mw );

TQString n = name;

tb->setName( n );

mw->addToolBar( tb, text );

}

ls << s;

TQValueList<uint> ll;

ll << l;

}

void DesignerOutputDockImpl::clearError()

void setTables( const TQStringList & );

TQMap<TQString, TQStringList> fields() const;

void setFields( const TQMap<TQString, TQStringList> & );

void close() const;

TQSqlDatabase* connection();

private:

void setCurrentWidget( TQWidget * );

TQPtrList<TQAction> actionList() const;

TQAction *createAction( const TQString& text, const TQIconSet& icon, const TQString& menuText, int accel,

void addAction( TQAction * );

void removeAction( TQAction * );

void preview() const;

#include <tdelocale.h>

EditFunctions::EditFunctions( TQWidget *parent, FormWindow *fw, bool justSlots )

{

connect( helpButton, TQ_SIGNAL( clicked() ), MainWindow::self, TQ_SLOT( showDialogHelp() ) );

}

}

if ( functionListView->firstChild() )

functionListView->setCurrentItem( functionListView->firstChild() );

// Enable rename for all TQListViewItems

TQListViewItemIterator lvit = functionListView->firstChild();

for ( ; *lvit; lvit++ )

// Connect listview signal to signal-relay

TQObject::connect( functionListView,

TQValueList<MetaDataBase::Function>::Iterator fit;

if ( !functionList.isEmpty() ) {

for ( fit = functionList.begin(); fit != functionList.end(); ++fit ) {

TQValueList<FunctItem>::Iterator it = functList.begin();

for ( ; it != functList.end(); ++it ) {

if ( MetaDataBase::normalizeFunction( (*it).oldName ) ==

MetaDataBase::normalizeFunction( (*fit).function ) ) {

break;

}

}

}

}

TQValueList<FunctItem> invalidItems;

if ( !functList.isEmpty() ) {

bool illegalSpace = s.find( ' ' ) != -1 && s.find( ' ' ) < s.find( '(' );

if ( startNum || noParens || illegalSpace || lst.find( function.function ) != -1 ) {

invalidItems.append( (*it) );

continue;

}

for ( fit = functionList.begin(); fit != functionList.end(); ++fit ) {

if ( MetaDataBase::normalizeFunction( (*fit).function ) ==

MetaDataBase::normalizeFunction( (*it).oldName ) ) {

break;

}

}

"Remove these functions?" ), i18n( "&Yes" ), i18n( "&No" ) ) == 0 ) {

TQValueList<FunctItem>::Iterator it = functList.begin();

while ( it != functList.end() ) {

TQValueList<FunctItem>::Iterator vit = invalidItems.begin();

for ( ; vit != invalidItems.end(); ++vit ) {

if ( (*vit).newName == (*it).newName ) {

invalidItems.remove( vit );

break;

}

}

functionIds.remove( fit );

delete litem;

if ( functionListView->currentItem() )

currentItemChanged( functionListView->currentItem() );

break;

}

}

if ( functionListView->firstChild() ) {

functionListView->setCurrentItem( functionListView->firstChild() );

}

}

formWindow->mainWindow()->objectHierarchy()->updateFormDefinitionView();

{

TQListViewItem *i = new TQListViewItem( functionListView );

i->setPixmap( 0, SmallIcon( "designer_editslots.png" , KDevDesignerPartFactory::instance()) );

i->setText( 1, "void" );

i->setText( 2, "virtual" );

}

functionListView->setCurrentItem( i );

functionListView->ensureItemVisible( i );

functionName->setFocus();

functionName->selectAll();

if ( !functionListView->currentItem() )

return;

removedFunctions << MetaDataBase::normalizeFunction( functionListView->currentItem()->text( 0 ) );

int delId = functionIds[ functionListView->currentItem() ];

TQValueList<FunctItem>::Iterator it = functList.begin();

functionIds.remove( functionListView->currentItem() );

delete functionListView->currentItem();

if ( functionListView->currentItem() )

currentItemChanged( functionListView->currentItem() );

}

void EditFunctions::currentItemChanged( TQListViewItem *i )

{

functionName->setText( "" );

functionAccess->setCurrentItem( 0 );

if ( !i ) {

return;

}

functionName->setText( i->text( 0 ) );

editType->setText( i->text( 1 ) );

TQString specifier = i->text( 2 );

else

functionType->setCurrentItem( 1 );

}

void EditFunctions::currentTextChanged( const TQString &txt )

while ( it.current() ) {

if ( MetaDataBase::normalizeFunction( it.current()->text( 0 ) ) == function ) {

functionListView->setCurrentItem( it.current() );

currentItemChanged( it.current() );

return;

}

}

if ( functionListView->firstChild() )

}

void EditFunctions::emitItemRenamed( TQListViewItem *, int, const TQString & text )

public:

void setCurrentFunction( const TQString &function );

void functionAdd( const TQString &access = TQString(),

if ( !editor->find( comboFind->currentText(), checkCase->isChecked(),

checkWords->isChecked(), radioForward->isChecked(), !checkBegin->isChecked() ) )

else

}

void FindDialog::setEditor( EditorInterface * e, TQObject * fw )

{

if ( fw != formWindow )

formWindow = fw;

if ( editor )

editor->release();

FormFile::FormFile( const TQString &fn, bool temp, Project *p, const char *name )

: filename( fn ), fileNameTemp( temp ), pro( p ), fw( 0 ), ed( 0 ),

{

MetaDataBase::addEntry( this );

fake = qstrcmp( name, "qt_fakewindow" ) == 0;

pro->addFormFile( this );

loadCode();

if ( !temp )

connect(this, TQ_SIGNAL(somethingChanged(FormFile* )), this, TQ_SLOT(emitNewStatus(FormFile* )));

}

fw = f;

if ( fw )

fw->setFormFile( this );

TQTimer::singleShot( 0, this, TQ_SLOT( notifyFormWindowChange() ) );

}

if ( fn == filename )

return;

if ( fn.isEmpty() ) {

if ( filename.find( "unnamed" ) != 0 )

filename = createUnnamedFileName();

return;

} else {

}

filename = fn;

timeStamp.setFileName( filename + codeExtension() );

if ( fileNameTemp )

return saveAs();

if ( !ignoreModified && !isModified() )

if ( ed )

ed->save();

if ( formWindow() && isModified( WFormWindow ) ) {

if ( withMsgBox ) {

if ( !formWindow()->checkCustomWidgets() )

}

if ( TQFile::exists( pro->makeAbsolute( filename ) ) ) {

if ( MainWindow::self )

MainWindow::self->statusMessage( i18n( "Failed to save file '%1'.").arg( formCodeOnly ? codeFile(): filename ) );

if ( formCodeOnly )

return saveAs();

}

if ( MainWindow::self )

arg( formCodeOnly ? codeFile() : filename ));

} else {

if ( !Resource::saveFormCode(this, MetaDataBase::languageInterface(pro->language())) )

}

timeStamp.update();

}

bool FormFile::saveAs( bool ignoreModified )

f.replace( "::", "_" );

f = pro->makeAbsolute( f + ".ui" );

}

if ( ignoreModified ) {

TQString dir = TQStringList::split( ':', pro->iFace()->customSetting( "QTSCRIPT_PACKAGES" ) ).first();

f = TQFileInfo( f ).fileName();

i18n( "Save Form '%1' As").arg( formName() )/*,

MainWindow::self ? &MainWindow::self->lastSaveFilter : 0*/ );

if ( fn.isEmpty() )

TQFileInfo fi( fn );

if ( fi.extension() != "ui" )

fn += ".ui";

filename = pro->makeRelative( fn );

TQFileInfo relfi( filename );

if ( relfi.exists() ) {

i18n( "The file already exists. Do you wish to overwrite it?" ),

TQMessageBox::Yes,

TQMessageBox::No ) == TQMessageBox::Yes ) {

} else {

filename = f;

}

} else {

}

}

filename = f;

}

timeStamp.setFileName( pro->makeAbsolute( codeFile() ) );

if ( ed && formWindow() )

ed->setCaption( i18n( "Edit %1" ).arg( formWindow()->name() ) );

if ( pro->isDummy() )

fw->mainWindow()->addRecentlyOpenedFile( fn );

}

bool FormFile::close()

}

if ( formWindow() )

return formWindow()->close();

}

bool FormFile::closeEvent()

{

if ( !isModified() && fileNameTemp ) {

pro->removeFormFile( this );

}

if ( !isModified() )

if ( editor() )

editor()->save();

i18n( "&Yes" ), i18n( "&No" ), i18n( "&Cancel" ), 0, 2 ) ) {

case 0: // save

if ( !save() )

case 1: // don't save

loadCode();

if ( ed )

MainWindow::self->workspace()->update();

break;

case 2: // cancel

default:

break;

}

if ( MainWindow::self )

MainWindow::self->updateFunctionList();

}

void FormFile::setModified( bool m, int who )

bool FormFile::isFormWindowModified() const

{

if ( !formWindow() || !formWindow()->commandHistory() )

return formWindow()->commandHistory()->isModified();

}

formWindow()->setFocus();

return;

}

}

bool FormFile::setupUihFile( bool askForUih )

if ( !pro->isCpp() || !askForUih ) {

if ( !hasFormCode() ) {

createFormCode();

}

codeFileStat = FormFile::Ok;

}

if ( codeFileStat != FormFile::Ok && !ed ) {

if ( hasFormCode() ) {

i18n( "Use Existing" ), i18n( "Create New" ),

i18n( "Cancel" ), 2, 2 );

if ( i == 2 )

if ( i == 1 )

createFormCode();

} else {

if ( TQMessageBox::Yes != TQMessageBox::information( MainWindow::self, i18n( "Creating ui.h file" ),

i18n( "Do you want to create an new \"ui.h\" file?" ),

TQMessageBox::Yes, TQMessageBox::No ) )

createFormCode();

}

}

codeFileStat = FormFile::Ok;

}

SourceEditor *FormFile::showEditor( bool askForUih )

(*it).returnType, (*it).access ) +

"\n" + iface->createEmptyFunction();

}

}

void FormFile::load()

if ( !f.open( IO_ReadOnly ) ) {

cod = "";

setCodeFileState( FormFile::None );

}

TQTextStream ts( &f );

cod = ts.read();

if ( hasFormCode() && codeFileStat != FormFile::Ok )

setCodeFileState( FormFile::Deleted );

timeStamp.update();

}

bool FormFile::isCodeEdited() const

TQMap<TQString, TQString> funcs;

for ( TQValueList<LanguageInterface::Function>::Iterator it = functions.begin();

it != functions.end(); ++it ) {

for ( TQValueList<MetaDataBase::Function>::Iterator fit = oldFunctions.begin();

fit != oldFunctions.end(); ++fit ) {

TQString f( (*fit).function );

if ( MetaDataBase::normalizeFunction( f ) ==

MetaDataBase::normalizeFunction( (*it).name ) ) {

MetaDataBase::Function function;

function.function = make_func_pretty( (*it).name );

function.specifier = (*fit).specifier;

newFunctions << function;

funcs.insert( (*it).name, (*it).body );

if ( allowModify )

}

}

if ( allowModify && oldFunctions.count() > 0 )

MetaDataBase::setFunctionList( formWindow(), newFunctions );

}

{

if ( !editor() )

return;

cod = editor()->editorInterface()->text();

}

bool FormFile::isUihFileUpToDate()

{

if ( timeStamp.isUpToDate() )

if ( !editor() ) {

MainWindow::self->editSource();

tqDebug( "parse Code" );

}

checkTimeStamp();

}

void FormFile::addFunctionCode( MetaDataBase::Function function )

TQValueList<LanguageInterface::Function> funcs;

iface->functions( cod, &funcs );

for ( TQValueList<LanguageInterface::Function>::Iterator it = funcs.begin();

it != funcs.end(); ++it ) {

if ( MetaDataBase::normalizeFunction( (*it).name ) == MetaDataBase::normalizeFunction( function.function ) ) {

break;

}

}

"\n" + iface->createEmptyFunction();

cod += body;

if ( codeEdited ) {

emit somethingChanged( this );

}

}

arg( formWindow()->name() )/*,

MainWindow::self ? &MainWindow::self->lastSaveFilter : 0 */);

if ( allowBreak && fn.isEmpty() )

}

filename = pro->makeRelative( fn );

ff = pro->findFormFile( filename, this );

}

}

void FormFile::addConnection( const TQString &sender, const TQString &signal,

bool loadCode();

void load();

bool close();

bool closeEvent();

bool isModified( int who = WAnyOrAll );

void functionRetTypeChanged( const TQString &fuName, const TQString &oldType, const TQString &newType );

void showFormWindow();

static TQString createUnnamedFileName();

TQString formName() const;

bool hasTempFileName() const { return fileNameTemp; }

void setCodeFileState( UihState );

int codeFileState() const;

Project *project() const { return pro; }

#include <tqcheckbox.h>

FormSettings::FormSettings( TQWidget *parent, FormWindow *fw )

{

connect( buttonHelp, TQ_SIGNAL( clicked() ), MainWindow::self, TQ_SLOT( showDialogHelp() ) );

MetaDataBase::MetaInfo info = MetaDataBase::metaInfo( fw );

editPixmapFunction->setValidator( new AsciiValidator( TQString( ":" ), editPixmapFunction ) );

if ( formwindow->savePixmapInline() )

else if ( formwindow->savePixmapInProject() )

else

editPixmapFunction->setText( formwindow->pixmapLoaderFunction() );

radioProjectImageFile->setEnabled( !fw->project()->isDummy() );

spinSpacing->setValue( formwindow->layoutDefaultSpacing() );

info.author = editAuthor->text();

MetaDataBase::setMetaInfo( formwindow, info );

if ( formwindow->savePixmapInline() ) {

MetaDataBase::clearPixmapArguments( formwindow );

}

if ( radioPixmapInline->isChecked() ) {

} else if ( radioProjectImageFile->isChecked() ){

} else {

}

if ( checkLayoutFunctions->isChecked() )

else

formwindow->setPixmapLoaderFunction( editPixmapFunction->text() );

formwindow->setLayoutDefaultSpacing( spinSpacing->value() );

#include <tqt_windows.h>

static void flickerfree_update( TQWidget *w )

{

}

#endif

FormWindow::FormWindow( FormFile *f, MainWindow *mw, TQWidget *parent, const char *name )

: TQWidget( parent, name, WDestructiveClose ), mainwindow( mw ),

{

ff = f;

init();

FormWindow::FormWindow( FormFile *f, TQWidget *parent, const char *name )

: TQWidget( parent, name, WDestructiveClose ), mainwindow( 0 ),

{

ff = f;

init();

iface = 0;

proj = 0;

propertyWidget = 0;

mContainer = 0;

startWidget = endWidget = 0;

currTool = POINTER_TOOL;

unclippedPainter = 0;

setFocusPolicy( TQWidget::ClickFocus );

sizePreviewLabel = 0;

checkSelectionsTimer = new TQTimer( this, "checkSelectionsTimer" );

insertParent = 0;

connect( &commands, TQ_SIGNAL( undoRedoChanged( bool, bool, const TQString &, const TQString & ) ),

this, TQ_SIGNAL( undoRedoChanged( bool, bool, const TQString &, const TQString & ) ) );

setIcon( SmallIcon( "designer_form.png" , KDevDesignerPartFactory::instance()) );

setMainContainer( w );

propertyWidget = w;

targetContainer = 0;

defSpacing = BOXLAYOUT_DEFAULT_SPACING;

defMargin = BOXLAYOUT_DEFAULT_MARGIN;

}

void FormWindow::setMainWindow( MainWindow *w )

}

if ( !w )

return;

}

TQString s = w->name();

w->setName( s );

insertWidget( w );

TQRect r( currRect );

return;

if ( checkName ) {

TQString s = w->name();

w->setName( s );

}

void FormWindow::handleMousePress( TQMouseEvent *e, TQWidget *w )

{

CHECK_MAINWINDOW;

checkSelectionsTimer->stop();

if ( !sizePreviewLabel ) {

sizePreviewLabel = new TQLabel( this );

if ( !w->parentWidget() || WidgetFactory::layoutType( w->parentWidget() ) == WidgetFactory::NoLayout )

w->raise();

if ( ( e->state() & ControlButton ) ) { // with control pressed, always start rubber band selection

currRect = TQRect( 0, 0, -1, -1 );

startRectDraw( mapFromGlobal( e->globalPos() ), e->globalPos(), this, Rubber );

break;

bool sel = isWidgetSelected( w );

if ( !( ( e->state() & ControlButton ) || ( e->state() & ShiftButton ) ) ) { // control not pressed...

if ( !sel ) { // ...and widget no selectted: unselect all

} else { // ...widget selected

// only if widget has a layout (it is a layout meta widget or a laid out container!), unselect its childs

if ( WidgetFactory::layoutType( w ) != WidgetFactory::NoLayout ) {

TQObjectList *l = w->queryList( "TQWidget" );

for ( TQObject *o = l->first(); o; o = l->next() ) {

if ( !o->isWidgetType() )

continue;

if ( insertedWidgets.find( (TQWidget*)o ) )

}

delete l;

}

}

}

if ( ( ( e->state() & ControlButton ) || ( e->state() & ShiftButton ) ) &&

sel && e->button() == TQt::LeftButton ) { // control pressed and selected, unselect widget

break;

}

w = w->parentWidget();

if ( e->button() == TQt::LeftButton ) { // left button: store original geometry and more as the widget might start moving

widgetGeom = TQRect( w->pos(), w->size() );

oldPressPos = w->mapFromGlobal( e->globalPos() );

origPressPos = oldPressPos;

moving.clear();

if ( w->parentWidget() && !isMainContainer( w->parentWidget() ) && !isCentralWidget( w->parentWidget() ) ) {

targetContainer = w->parentWidget();

}

} else { // press was on the formwindow

if ( e->button() == TQt::LeftButton ) { // left button: start rubber selection and show formwindow properties

if ( !( ( e->state() & ControlButton ) || ( e->state() & ShiftButton ) ) ) {

TQObject *opw = propertyWidget;

propertyWidget = mainContainer();

if ( opw->isWidgetType() )

case BUDDY_TOOL:

if ( e->button() != TQt::LeftButton )

break;

if ( currTool == BUDDY_TOOL ) {

if ( !::tqt_cast<TQLabel*>(w) )

break;

mainWindow()->statusMessage( i18n( "Set buddy for '%1' to..." ).arg( w->name() ) );

} else {

mainWindow()->statusMessage( i18n( "Connect '%1' with..." ).arg( w->name() ) );

currentPos = startPos;

startWidget = designerWidget( w );

endWidget = startWidget;

drawConnectionLine();

break;

case ORDER_TOOL:

TQWidgetList oldl = MetaDataBase::tabOrder( this );

TabOrderCommand *cmd = new TabOrderCommand( i18n( "Change Tab Order" ), this, oldl, stackedWidgets );

cmd->execute();

updateOrderIndicators();

}

break;

TQWidgetList oldl = MetaDataBase::tabOrder( this );

TabOrderCommand *cmd = new TabOrderCommand( i18n( "Change Tab Order" ), this, oldl, stackedWidgets );

cmd->execute();

updateOrderIndicators();

}

default:

if ( x - p.x() != 0 || y - p.y() != 0 ) { // if we actually have to move

if ( !checkedSelectionsForMove ) { // if not checked yet, check if the correct widget are selected...

if ( !isWidgetSelected( w ) ) { // and unselect others. Only siblings can be moved at the same time

selectWidget( w );

}

checkSelectionsForMove( w );

}

sizePreviewLabel->raise();

sizePreviewLabel->show();

#if defined(TQ_WS_WIN32)

#endif

} else { // if we don't need to move, do some indication

TQRect lg( mapFromGlobal( e->globalPos() ) + TQPoint( 16, 16 ), sizePreviewLabel->size() );

break;

case CONNECT_TOOL:

restoreConnectionLine();

if ( wid )

wid = designerWidget( wid );

if ( wid && ( isMainContainer( wid ) || insertedWidgets.find( wid ) ) && wid->isVisibleTo( this ) )

if ( !validForBuddy )

break;

restoreConnectionLine();

if ( wid )

wid = designerWidget( wid );

if ( wid && canBeBuddy( wid ) && wid->isVisibleTo( this ) )

}

// doesn't need to be a command, the MoveCommand does reparenting too

for ( TQMap<TQWidget*, TQPoint>::Iterator it = moving.begin(); it != moving.end(); ++it ) {

TQWidget *i = it.key();

if ( !emitSelChanged && ::tqt_cast<TQButton*>(i) ) {

if ( ::tqt_cast<TQButtonGroup*>(i->parentWidget()) || ::tqt_cast<TQButtonGroup*>(wa) )

if ( !::tqt_cast<TQButtonGroup*>(wa) ) {

if ( ::tqt_cast<TQButtonGroup*>(i->parentWidget()) )

( (TQButtonGroup*)i->parentWidget() )->remove( (TQButton*)i );

}

}

TQPoint pos = wa->mapFromGlobal( i->mapToGlobal( TQPoint(0,0) ) );

raiseSelection( i );

raiseChildSelections( i );

widgetChanged( i );

oldPos, newPos, oldParent, newParent ) );

} else if ( drawRubber ) { // we were drawing a rubber selection

endRectDraw(); // get rid of the rectangle

selectWidgets(); // select widgets which intersect the rect

emitSelectionChanged(); // inform about selection changes

if ( propertyWidget )

emitShowProperties( propertyWidget );

"buddy", startWidget->property( "buddy" ),

endWidget->name(), endWidget->name(),

oldBuddy );

cmd->execute();

emitUpdateProperties( startWidget );

}

}

break;

}

insertParent = 0;

delete buffer;

buffer = 0;

e->key() == Key_Down ) &&

propertyWidget->isWidgetType() )

checkSelectionsForMove( (TQWidget*)propertyWidget );

if ( e->key() == Key_Left || e->key() == Key_Right ||

e->key() == Key_Up || e->key() == Key_Down ) {

TQWidgetList widgets;

if ( !widgets.isEmpty() ) {

MoveCommand *cmd = new MoveCommand( i18n( "Move" ), this,

widgets, oldPos, newPos, 0, 0 );

cmd->execute();

}

}

{

WidgetSelection *s = usedSelections.find( w );

if ( !w->isVisibleTo( this ) )

else if ( s )

s->updateGeometry();

}

{

TQPtrDictIterator<WidgetSelection> it( usedSelections );

for ( ; it.current(); ++it )

usedSelections.clear();

if ( changePropertyDisplay ) {

{

TQPoint pos( p );

pos = mapFromGlobal( global );

if ( t == Rubber )

unclippedPainter->setPen( TQPen( color0, 1 ) );

if ( t == Insert )

if ( oldRectValid )

unclippedPainter->drawRect( currRect );

if ( r.width() > 1 || r.height() > 1 ) {

currRect = r;

if ( t == Insert ) {

TQString t = i18n( "%1/%2" );

}

unclippedPainter->setClipRegion( TQRegion( rect() ).subtract( TQRect( sizePreviewPos, sizePreviewPixmap.size() ) ) );

unclippedPainter->drawRect( currRect );

} else {

if ( t == Insert )

drawSizePreview( pos, i18n("Use Size Hint") );

}

{

if ( w->isWidgetType() )

return usedSelections.find( (TQWidget*)w ) != 0;

}

void FormWindow::moveSelectedWidgets( int dx, int dy )

void FormWindow::checkSelectionsForMove( TQWidget *w )

{

moving.clear();

if ( l ) {

TQPtrDictIterator<WidgetSelection> it( usedSelections );

void FormWindow::invalidCheckedSelections()

{

}

void FormWindow::checkPreviewGeometry( TQRect &r )

if ( currTool == ORDER_TOOL )

repositionOrderIndicators();

if ( isVisible() )

#if defined(TQ_WS_WIN32)

#endif

}

repaintSelection( (TQWidget*)opw );

}

showPropertiesTimer->stop();

showPropertiesTimerDone();

}

{

if ( w == propertyWidget ) {

updatePropertiesTimer->stop();

}

}

void FormWindow::emitSelectionChanged()

{

selectionChangedTimer->stop();

}

void FormWindow::updatePropertiesTimerDone()

void FormWindow::currentToolChanged()

{

CHECK_MAINWINDOW;

int t = mainwindow->currentTool();

if ( currTool == t && t != ORDER_TOOL )

return;

}

startWidget = endWidget = 0;

insertParent = 0;

delete buffer;

buffer = 0;

currTool = t;

if ( hasFocus() )

mainWindow()->statusBar()->clear();

void FormWindow::showOrderIndicators()

{

hideOrderIndicators();

TQObjectList *l = mainContainer()->queryList( "TQWidget" );

stackedWidgets = MetaDataBase::tabOrder( this );

if ( l ) {

"the generated code will not compile.\n"

"Do you want to save this form now?" );

if ( TQMessageBox::information( mainWindow(), i18n( "Save Form" ), txt ) == 1 )

}

}

void FormWindow::setPropertyShowingBlocked( bool b )

insertedWidgets[ (void*)o ] ) {

TQWidget *w = (TQWidget*)o;

const TQMetaProperty* text =

const TQMetaProperty* title =

const TQMetaProperty* pageTitle =

if ( text )

find_accel( w->property( "text" ).toString(), accels, w );

if ( title )

delete l;

}

TQWidget *wid;

for ( TQMap<TQChar, TQWidgetList >::Iterator it = accels.begin(); it != accels.end(); ++it ) {

if ( (*it).count() > 1 ) {

switch ( TQMessageBox::information( mainWindow(), i18n( "Check Accelerators" ),

i18n( "Accelerator '%1' is used once.", "Accelerator '%1' is used %n times.", (*it).count()

).arg( it.key().upper() ),

i18n( "&Select" ),

i18n( "&Cancel" ), TQString(), 2 ) ) {

case 0: // select

for ( wid = (*it).first(); wid; wid = (*it).next() )

return;

case 1: // cancel

return;

void FormWindow::selectAll()

{

TQObjectList *l = mainContainer()->queryList( "TQWidget" );

if ( l ) {

for ( TQObject *o = l->first(); o; o = l->next() ) {

delete l;

}

emitSelectionChanged();

if ( propertyWidget )

emitShowProperties( propertyWidget );

TQWidgetList widgets( selectedWidgets() );

LayoutHorizontalCommand *cmd = new LayoutHorizontalCommand( i18n( "Lay Out Horizontally" ),

this, mainContainer(), 0, widgets );

commandHistory()->addCommand( cmd );

cmd->execute();

}

TQWidgetList widgets( selectedWidgets() );

LayoutVerticalCommand *cmd = new LayoutVerticalCommand( i18n( "Lay Out Vertically" ),

this, mainContainer(), 0, widgets );

commandHistory()->addCommand( cmd );

cmd->execute();

}

TQWidgetList widgets( selectedWidgets() );

LayoutHorizontalSplitCommand *cmd = new LayoutHorizontalSplitCommand( i18n( "Lay Out Horizontally (in splitter)" ),

this, mainContainer(), 0, widgets );

commandHistory()->addCommand( cmd );

cmd->execute();

}

TQWidgetList widgets( selectedWidgets() );

LayoutVerticalSplitCommand *cmd = new LayoutVerticalSplitCommand( i18n( "Lay Out Vertically (in splitter)" ),

this, mainContainer(), 0, widgets );

commandHistory()->addCommand( cmd );

cmd->execute();

}

TQWidgetList widgets( selectedWidgets() );

LayoutGridCommand *cmd = new LayoutGridCommand( i18n( "Lay Out in a Grid" ),

this, mainContainer(), 0, widgets, xres, yres );

commandHistory()->addCommand( cmd );

cmd->execute();

}

}

LayoutHorizontalCommand *cmd = new LayoutHorizontalCommand( i18n( "Lay Out Children Horizontally" ),

this, mainContainer(), w, widgets );

commandHistory()->addCommand( cmd );

cmd->execute();

}

}

LayoutVerticalCommand *cmd = new LayoutVerticalCommand( i18n( "Lay Out Children Vertically" ),

this, mainContainer(), w, widgets );

commandHistory()->addCommand( cmd );

cmd->execute();

}

}

LayoutGridCommand *cmd = new LayoutGridCommand( i18n( "Lay Out Children in a Grid" ),

this, mainContainer(), w, widgets, xres, yres );

commandHistory()->addCommand( cmd );

cmd->execute();

}

if ( commands.isEmpty() )

return;

MacroCommand *cmd = new MacroCommand( i18n( "Break Layout" ), this, commands );

commandHistory()->addCommand( cmd );

cmd->execute();

bool FormWindow::hasInsertedChildren( TQWidget *w ) const

{

if ( !w )

w = WidgetFactory::containerOfWidget( w );

if ( !w )

TQObjectList *l = w->queryList( "TQWidget" );

if ( !l || !l->first() ) {

delete l;

}

for ( TQObject *o = l->first(); o; o = l->next() ) {

( (TQWidget*)o )->isVisibleTo( (FormWindow*)this ) &&

insertedWidgets.find( (TQWidget*)o ) ) {

delete l;

}

}

delete l;

}

bool FormWindow::allowMove( TQWidget *w )

w = w->parentWidget();

while ( w ) {

if ( ( isMainContainer( w ) || insertedWidgets.find( w ) ) && WidgetFactory::layoutType( w ) == WidgetFactory::NoLayout )

w = w->parentWidget();

}

}

for ( ; it.current();) {

if ( it.current() != w &&

qstrcmp( it.current()->name(), s.latin1() ) == 0 ) {

if ( !changeIt )

break;

s = orig + "_" + TQString::number( ++num );

for ( a = al.first(); a; a = al.next() ) {

if ( a != w &&

qstrcmp( a->name(), s.latin1() ) == 0 ) {

if ( !changeIt )

break;

s = orig + "_" + TQString::number( ++num );

for ( TQObject *o = l->first(); o; o = l->next() ) {

if ( o != w &&

qstrcmp ( o->name(), s.latin1() ) == 0 ) {

if ( !changeIt )

break;

s = orig + "_" + TQString::number( ++num );

}

if ( ::tqt_cast<TQMainWindow*>(mainContainer()) ) {

if ( !found ) {

for ( TQObject *o = l->first(); o; o = l->next() ) {

if ( o != w &&

qstrcmp( o->name(), s.latin1() ) == 0 ) {

if ( !changeIt )

break;

s = orig + "_" + TQString::number( ++num );

}

if ( !found )

}

bool FormWindow::isCustomWidgetUsed( MetaDataBase::CustomWidget *w )

for ( ; it.current(); ++it ) {

if ( it.current()->isA( "CustomWidget" ) ) {

if ( qstrcmp( WidgetFactory::classNameOf( it.current() ), w->className.utf8() ) == 0 )

}

}

}

bool FormWindow::isDatabaseWidgetUsed() const

for ( ; it.current(); ++it ) {

TQString c( it.current()->className() );

if ( dbClasses.contains( c ) > 0 ) {

}

}

#endif

}

bool FormWindow::isDatabaseAware() const

{

#ifndef TQT_NO_SQL

if ( TQString(mContainer->className()) == "QDesignerDataBrowser" || TQString(mContainer->className()) == "QDesignerDataView" )

return isDatabaseWidgetUsed();

#else

#endif

}

{

while ( c && !c->isTopLevel() ) {

if ( c == p )

c = c->parentWidget();

}

}

TQWidget *FormWindow::containerAt( const TQPoint &pos, TQWidget *notParentOf )

{

pixInline = b;

if ( b )

}

void FormWindow::setSavePixmapInProject( bool b )

{

pixProject = b;

if ( b )

}

void FormWindow::setPixmapLoaderFunction( const TQString &func )

if ( !l )

return;

for ( TQObject *o = l->first(); o; o = l->next() )

delete l;

}

bool FormWindow::isCentralWidget( TQObject *w ) const

{

if ( !::tqt_cast<TQMainWindow*>(mainContainer()) )

return w == ((TQMainWindow*)mainContainer())->centralWidget();

}

virtual void breakLayout( TQWidget *w );

virtual void selectAll();

virtual void updateSelection( TQWidget *w );

virtual void raiseSelection( TQWidget *w );

virtual void repaintSelection( TQWidget *w );

virtual void selectWidgets();

bool isWidgetSelected( TQObject *w );

virtual void updateChildSelections( TQWidget *w );

virtual MainWindow *mainWindow() const { return mainwindow; }

bool checkCustomWidgets();

virtual void removeWidget( TQWidget *w );

virtual void deleteWidgets();

virtual void editAdjustSize();

bool savePixmapInProject() const;

void setSavePixmapInProject( bool b );

void setActiveObject( TQObject *o );

if ( rtti() == Function &&

MainWindow::self->currProject()->isCpp() &&

( txt == "init()" || txt == "destroy()" ) ) {

if ( txt == "init()" )

setText( 0, txt + " " + "(Constructor)" );

else

setText( 0, txt + " " + "(Destructor)" );

TQListViewItem::paintCell( p, g, column, width, align );

setText( 0, txt );

} else {

TQListViewItem::paintCell( p, g, column, width, align );

}

init_colors();

setDefaultRenameAction( Accept );

normalMenu = 0;

tabWidgetMenu = 0;

addColumn( i18n( "Name" ) );

connect( this, TQ_SIGNAL( contextMenuRequested( TQListViewItem *, const TQPoint&, int ) ),

this, TQ_SLOT( showRMBMenu( TQListViewItem *, const TQPoint & ) ) );

}

setColumnWidthMode( 1, Manual );

}

void HierarchyList::keyPressEvent( TQKeyEvent *e )

{

if ( e->key() == Key_Shift || e->key() == Key_Control )

else

TQListView::keyPressEvent( e );

}

void HierarchyList::keyReleaseEvent( TQKeyEvent *e )

{

TQListView::keyReleaseEvent( e );

}

void HierarchyList::viewportMousePressEvent( TQMouseEvent *e )

{

if ( e->state() & ShiftButton || e->state() & ControlButton )

else

TQListView::viewportMousePressEvent( e );

}

return 0;

if ( formWindow == o ) {

if ( deselect )

formWindow->emitShowProperties( formWindow );

return 0;

}

}

} else if ( ::tqt_cast<TQAction*>(o) ) {

MainWindow::self->actioneditor()->setCurrentAction( (TQAction*)o );

}

if ( deselect )

return o;

}

if ( !w->parentWidget() ||

WidgetFactory::layoutType( w->parentWidget() ) == WidgetFactory::NoLayout )

w->raise();

}

}

return;

if ( o->isWidgetType() && ( (TQWidget*)o )->isVisibleTo( formWindow ) ) {

TQWidget *w = (TQWidget*)o;

}

}

{

if ( TQString( o->name() ).startsWith( "qt_dead_widget_" ) )

return;

if ( ::tqt_cast<TQMainWindow*>(o) ) {

TQObject *cw = ( (TQMainWindow*)o )->centralWidget();

if ( cw ) {

o = cw;

}

}

TQListViewItem *item = 0;

item = new HierarchyItem( HierarchyItem::Widget, this, 0, name, className, dbInfo );

else

item = new HierarchyItem( HierarchyItem::Widget, parent, 0, name, className, dbInfo );

if ( !parent )

item->setPixmap( 0, DesignerFormPix );

else if ( ::tqt_cast<TQLayoutWidget*>(o) )

if ( widgetStacks->findRef( stack ) != -1 )

continue;

widgetStacks->append( stack );

for ( obj = l2->last(); obj; obj = l2->prev() ) {

if ( qstrcmp( obj->className(),

"TQWidgetStackPrivate::Invisible" ) == 0 ||

TQListViewItemIterator it( this );

while ( it.current() ) {

if ( ( (HierarchyItem*)it.current() )->object() == o ) {

setCurrentItem( it.current() );

ensureItemVisible( it.current() );

return;

}

++it;

new DeleteWizardPageCommand( i18n( "Delete Page %1 of %2" ).

arg( dw->pageTitle() ).arg( wiz->name() ),

formWindow, wiz,

formWindow->commandHistory()->addCommand( cmd );

cmd->execute();

}

// ------------------------------------------------------------

FormDefinitionView::FormDefinitionView( TQWidget *parent, FormWindow *fw )

{

header()->hide();

removeColumn( 1 );

connect( this, TQ_SIGNAL( itemRenamed( TQListViewItem *, int, const TQString & ) ),

this, TQ_SLOT( renamed( TQListViewItem * ) ) );

}

void FormDefinitionView::setup()

HierarchyItem *itemDef = new HierarchyItem( HierarchyItem::DefinitionParent, this, 0,

i18n( *dit ), TQString(), TQString() );

itemDef->setPixmap( 0, DesignerFolderPix );

TQStringList entries =

lIface->definitionEntries( *dit, formWindow->mainWindow()->designerInterface() );

HierarchyItem *item = 0;

for ( TQStringList::Iterator eit = entries.begin(); eit != entries.end(); ++eit ) {

item = new HierarchyItem( HierarchyItem::Definition,

itemDef, item, *eit, TQString(), TQString() );

}

}

lIface->release();

void FormDefinitionView::setupVariables()

{

bool pubOpen, protOpen, privOpen;

TQListViewItem *i = firstChild();

while ( i ) {

if ( i->rtti() == HierarchyItem::VarParent ) {

HierarchyItem *itemVar = new HierarchyItem( HierarchyItem::VarParent, this, 0, i18n( "Class Variables" ),

TQString(), TQString() );

itemVar->setPixmap( 0, DesignerFolderPix );

itemVarPriv = new HierarchyItem( HierarchyItem::VarPrivate, itemVar, 0, i18n( "private" ),

TQString(), TQString() );

--it;

}

}

itemVarPriv->setOpen( privOpen );

itemVarProt->setOpen( protOpen );

itemVarPubl->setOpen( pubOpen );

return;

bool fuPub, fuProt, fuPriv, slPub, slProt, slPriv;

TQListViewItem *i = firstChild();

while ( i ) {

if ( i->rtti() == HierarchyItem::SlotParent ||

}

}

itemFunctPubl->setOpen( fuPub );

itemFunctProt->setOpen( fuProt );

itemFunctPriv->setOpen( fuPriv );

itemPublic->setOpen( slPub );

itemProtected->setOpen( slProt );

itemPrivate->setOpen( slPriv );

TQString(), TQString() );

if ( !pix.isNull() )

item->setPixmap( 0, pix );

setCurrentItem( item );

ensureItemVisible( item );

tqApp->processEvents();

if ( formWindow->project()->isCpp() )

switch( i->rtti() ) {

case HierarchyItem::FunctPublic:

break;

case HierarchyItem::FunctProtected:

break;

case HierarchyItem::FunctPrivate:

break;

case HierarchyItem::SlotPublic:

break;

case HierarchyItem::SlotProtected:

break;

case HierarchyItem::SlotPrivate:

break;

case HierarchyItem::VarPublic:

case HierarchyItem::VarProtected:

// refresh the functions list in the metadatabase

SourceEditor *editor = formFile->editor();

if ( editor )

EditFunctions dlg( this, formWindow );

if ( addFunc )

const int GOIMPL = 5;

TQPopupMenu menu;

if ( i->rtti() == HierarchyItem::FunctParent || i->rtti() == HierarchyItem::SlotParent ||

i->rtti() == HierarchyItem::VarParent ) {

menu.insertItem( SmallIcon( "designer_editslots.png" , KDevDesignerPartFactory::instance()), i18n( "Properties" ), PROPS );

if ( MetaDataBase::hasEditor( formWindow->project()->language() ) )

menu.insertItem( i18n( "Goto Implementation" ), GOIMPL );

}

if ( insertDelete || i->rtti() == HierarchyItem::Variable ||

i->rtti() == HierarchyItem::Function || i->rtti() == HierarchyItem::Slot ||

menu.insertSeparator();

menu.insertItem( SmallIcon( "designer_editcut.png" , KDevDesignerPartFactory::instance()), i18n( "Delete" ), DEL );

}

int res = menu.exec( pos );

if ( res == -1 )

return;

if ( res == EDIT ) {

switch( i->rtti() ) {

case HierarchyItem::FunctParent:

break;

case HierarchyItem::SlotParent:

break;

case HierarchyItem::VarParent:

case HierarchyItem::VarPublic:

if ( i )

varDia.setCurrentItem( i->text( 0 ) );

if ( varDia.exec() == TQDialog::Accepted )

break;

}

case HierarchyItem::Definition:

return;

if ( i->rtti() == HierarchyItem::Definition )

i = i->parent();

dia.setCaption( i18n( "Edit %1" ).arg( i->text( 0 ) ) );

TQStringList entries = lIface->definitionEntries( i->text( 0 ), MainWindow::self->designerInterface() );

dia.setList( entries );

i = i->parent();

switch( i->rtti() ) {

case HierarchyItem::SlotPublic:

break;

case HierarchyItem::SlotProtected:

break;

case HierarchyItem::SlotPrivate:

break;

case HierarchyItem::FunctPublic:

break;

case HierarchyItem::FunctProtected:

break;

case HierarchyItem::FunctPrivate:

break;

default:

insertEntry( i );

}

if ( i && i->rtti() == HierarchyItem::Variable ) {

TQString varName = i->text( 0 );

varName = varName.simplifyWhiteSpace();

if ( varName[(int)varName.length() - 1] != ';' )

setTabToolTip( cb.lv, i18n( "List of all classes and its declarations of the current source file" ) );

ciface->onClick( this, TQ_SLOT( jumpTo( const TQString &, const TQString &, int ) ) );

classBrowsers->insert( *it, cb );

}

}

}

editor = 0;

}

setTabEnabled( fView, fw && fw->project()->isCpp() );

if ( fw == formwindow ) {

}

setTabEnabled( listview, !!se->formWindow() && !se->formWindow()->isFake() );

formwindow = 0;

listview->setFormWindow( 0 );

it != classBrowsers->end(); ++it ) {

if ( it.key() == se->project()->language() ) {

(*it).iface->update( se->text() );

showPage( (*it).lv );

} else {

(*it).iface->clear();

}

}

public:

virtual void setup();

virtual void setCurrent( TQObject *o );

void setFormWindow( FormWindow *fw ) { formWindow = fw; }

void drawContentsOffset( TQPainter *p, int ox, int oy,

int cx, int cy, int cw, int ch ) {

triggerUpdate();

TQListView::drawContentsOffset( p, ox, oy, cx, cy, cw, ch );

}

#include <tdelocale.h>

IconViewEditor::IconViewEditor( TQWidget *parent, TQWidget *editWidget, FormWindow *fw )

{

connect( buttonHelp, TQ_SIGNAL( clicked() ), MainWindow::self, TQ_SLOT( showDialogHelp() ) );

iconview = (TQIconView*)editWidget;

itemText->setText( "" );

itemPixmap->setText( "" );

TQIconViewItem *i = 0;

for ( i = iconview->firstItem(); i; i = i->nextItem() ) {

{

TQIconViewItem *i = new TQIconViewItem( preview, i18n( "New Item" ) );

preview->setCurrentItem( i );

itemText->setFocus();

itemText->selectAll();

}

{

delete preview->currentItem();

if ( preview->currentItem() )

}

void IconViewEditor::currentItemChanged( TQIconViewItem *i )

{

itemText->setText( "" );

itemPixmap->setText( "" );

if ( !i ) {

return;

}

itemDeletePixmap->setEnabled( i->pixmap() && !i->pixmap()->isNull() );

itemText->setText( i->text() );

if ( i->pixmap() )

itemPixmap->setPixmap( *i->pixmap() );

}

void IconViewEditor::currentTextChanged( const TQString &txt )

preview->currentItem()->setPixmap( pix );

itemPixmap->setPixmap( pix );

}

void IconViewEditor::deletePixmap()

preview->currentItem()->setPixmap( TQPixmap() );

itemPixmap->setText( "" );

}

bool KDevDesignerPart::saveFile()

{

return false;

m_widget->actionFileSaveAll->activate();

return true;

Layout::Layout( const TQWidgetList &wl, TQWidget *p, FormWindow *fw, TQWidget *lb, bool doSetup, bool splitter )

: widgets( wl ), parent( p ), formWindow( fw ), isBreak( !doSetup ), useSplitter( splitter )

{

layoutBase = lb;

if ( !doSetup && layoutBase )

oldGeometry = layoutBase->geometry();

}

if ( !lastList ) {

TQWidgetList l;

lists.append( l );

lastList = &lists.last();

}

bool Layout::prepareLayout( bool &needMove, bool &needReparent )

{

if ( !widgets.count() )

for ( TQWidget *w = widgets.first(); w; w = widgets.next() )

w->raise();

needMove = !layoutBase;

WidgetFactory::deleteLayout( layoutBase );

}

}

void Layout::finishLayout( bool needMove, TQLayout *layout )

it.key()->reparent( WidgetFactory::containerOfWidget( parent ), 0, ( *it ).topLeft(), it.key()->isVisibleTo( formWindow ) );

it.key()->resize( ( *it ).size() );

}

WidgetFactory::deleteLayout( layoutBase );

if ( parent != layoutBase && !::tqt_cast<TQMainWindow*>(layoutBase) ) {

layoutBase->hide();

for ( TQWidget *w = widgets.first(); w; w = widgets.next() ) {

if ( needReparent )

w->reparent( layoutBase->parentWidget(), 0,

if ( needResize ) {

TQMap<TQWidget*, TQRect>::Iterator it = rects.find( w );

if ( it != rects.end() )

for ( TQWidget *w = widgets.first(); w; w = widgets.next() ) {

if ( needReparent && w->parent() != layoutBase )

if ( !useSplitter ) {

if ( qstrcmp( w->className(), "Spacer" ) == 0 )

layout->addWidget( w, 0, ( (Spacer*)w )->alignment() );

for ( TQWidget *w = widgets.first(); w; w = widgets.next() ) {

if ( needReparent && w->parent() != layoutBase )

if ( !useSplitter ) {

if ( qstrcmp( w->className(), "Spacer" ) == 0 )

layout->addWidget( w, 0, ( (Spacer*)w )->alignment() );

int r;

for ( r = 0; r < nrows; r++ ) {

if ( cell( r, c ) && ( (c==0) || (cell( r, c) != cell( r, c-1) )) ) {

}

}

}

bool Grid::isWidgetEndCol( int c ) const

int r;

for ( r = 0; r < nrows; r++ ) {

if ( cell( r, c ) && ((c == ncols-1) || (cell( r, c) != cell( r, c+1) )) )

}

}

bool Grid::isWidgetStartRow( int r ) const

int c;

for ( c = 0; c < ncols; c++ ) {

if ( cell( r, c ) && ( (r==0) || (cell( r, c) != cell( r-1, c) )) )

}

}

bool Grid::isWidgetEndRow( int r ) const

int c;

for ( c = 0; c < ncols; c++ ) {

if ( cell( r, c ) && ((r == nrows-1) || (cell( r, c) != cell( r+1, c) )) )

}

}

{

TQWidget* w = cell( r, c );

if ( !w )

return ( !r || cell( r-1, c) != w ) && (!c || cell( r, c-1) != w);

}

{

int r,c;

for ( c = 0; c < ncols; c++ )

for ( r = 0; r < nrows; r++ )

for ( c = 0; c < ncols; c++ ) {

for ( r = 0; r < nrows; r++ ) {

if ( isWidgetTopLeft( r, c ) ) {

}

}

}

if ( cols[ c2] )

colspan++;

}

}

}

}

}

for ( w = widgets.first(); w; w = widgets.next() ) {

if ( grid->locateWidget( w, r, c, rs, cs) ) {

if ( needReparent && w->parent() != layoutBase )

if ( rs * cs == 1 ) {

layout->addWidget( w, r, c, ::tqt_cast<Spacer*>(w) ? ( (Spacer*)w )->alignment() : 0 );

} else {

Spacer::Spacer( TQWidget *parent, const char *name )

: TQWidget( parent, name, WMouseNoMask ),

{

setSizeType( Expanding );

}

void Spacer::paintEvent( TQPaintEvent * )

public:

virtual ~Layout() {}

virtual void doLayout() = 0;

class HorizontalLayout : public Layout

{

public:

void doLayout();

class VerticalLayout : public Layout

{

public:

void doLayout();

class GridLayout : public Layout

{

public:

~GridLayout();

void doLayout();

class ListBoxItemDrag : public TQStoredDrag

{

public:

~ListBoxItemDrag() {};

static bool canDecode( TQDragMoveEvent * event );

static bool decode( TQDropEvent * event, TQListBox * parent, TQListBoxItem * insertPoint );

void ListBoxDnd::confirmDrop( TQListBoxItem * )

{

}

bool ListBoxDnd::dropEvent( TQDropEvent * event )

if ( dMode & NullDrop ) { // combined with Move, a NullDrop will delete an item

event->accept();

emit dropped( 0 ); // a NullDrop

}

TQPoint pos = event->pos();

}

line->hide();

}

bool ListBoxDnd::mouseMoveEvent( TQMouseEvent * event )

if ( dMode & Move ) {

if ( dropConfirmed ) {

// ###FIX: memleak ? in internal mode, only pointers are transfered...

list.clear();

}

insertList( list ); // "show" items

}

}

}

}

int ListBoxDnd::buildList( ListBoxItemList & list )

TQListBoxItem * i = ((TQListBox *)src)->firstItem();

while ( i ) {

if ( i->isSelected() ) {

list.append( i );

}

i = i->next();

}

}

}

#include <tdelocale.h>

ListBoxEditor::ListBoxEditor( TQWidget *parent, TQWidget *editWidget, FormWindow *fw )

{

connect( helpButton, TQ_SIGNAL( clicked() ), MainWindow::self, TQ_SLOT( showDialogHelp() ) );

listbox = (TQListBox*)editWidget;

itemText->setText( "" );

itemPixmap->setText( "" );

TQListBoxItem *i = 0;

for ( i = listbox->firstItem(); i; i = i->next() ) {

{

TQListBoxItem *i = new TQListBoxText( preview, i18n("New Item") );

preview->setCurrentItem( i );

itemText->setFocus();

itemText->selectAll();

}

{

delete preview->item( preview->currentItem() );

if ( preview->currentItem() != -1 )

}

void ListBoxEditor::currentItemChanged( TQListBoxItem *i )

{

itemText->setText( "" );

itemPixmap->setText( "" );

if ( !i ) {

return;

}

itemDeletePixmap->setEnabled( i->pixmap() && !i->pixmap()->isNull() );

itemText->setText( i->text() );

if ( i->pixmap() )

itemPixmap->setPixmap( *i->pixmap() );

}

void ListBoxEditor::currentTextChanged( const TQString &txt )

if ( preview->currentItem() == -1 )

return;

if ( preview->item( preview->currentItem() )->pixmap() )

preview->changeItem( *preview->item( preview->currentItem() )->pixmap(), txt, preview->currentItem() );

else

preview->changeItem( txt, preview->currentItem() );

}

void ListBoxEditor::okClicked()

TQString txt = preview->item( preview->currentItem() )->text();

preview->changeItem( pix, txt, preview->currentItem() );

}

void ListBoxEditor::moveItemUp()

TQListBoxItem *i = preview->item( preview->currentItem() );

preview->changeItem( i->text(), preview->currentItem() );

}

ListBoxRename::ListBoxRename( TQListBox * eventSource, const char * name )

: TQObject( eventSource, name ),

{

src = eventSource;

src->installEventFilter( this );

ed = new TQLineEdit( src->viewport() );

ed->hide();

TQObject::connect( ed, TQ_SIGNAL( returnPressed() ),

this, TQ_SLOT( renameClickedItem() ) );

clickedItem->isSelected() &&

(clickedItem == src->itemAt( pos )) ) {

TQTimer::singleShot( 500, this, TQ_SLOT( showLineEdit() ) );

} else { // new item clicked

clickedItem = src->itemAt( pos );

ed->hide();

}

case TQEvent::MouseMove:

if ( ((TQMouseEvent *) event)->state() & TQt::LeftButton ) {

}

break;

case TQt::Key_F2:

clickedItem = src->item( src->currentItem() );

showLineEdit();

break;

case TQt::Key_Escape:

if ( !ed->isHidden() ) {

hideLineEdit(); // abort rename

}

break;

case TQt::Key_PageDown:

if ( !ed->isHidden() )

break;

}

break;

}

}

void ListBoxRename::showLineEdit()

ListDnd::ListDnd( TQScrollView * eventSource, const char * name )

: TQObject( eventSource, name ),

{

src = eventSource;

src->installEventFilter( this );

src->viewport()->installEventFilter( this );

default:

break;

}

}

bool ListDnd::dragEnterEvent( TQDragEnterEvent * event )

{

if ( dMode == None ) {

}

bool ok = ( ( ( dMode & Both ) == Both ) ||

if ( ok && canDecode( event ) ) {

event->accept();

if ( !( dMode & NullDrop ) ) {

updateLine( event->pos() );

line->show();

}

}

}

bool ListDnd::dragLeaveEvent( TQDragLeaveEvent * )

{

line->hide();

}

bool ListDnd::dragMoveEvent( TQDragMoveEvent * event )

if ( dragInside && dMode && !( dMode & NullDrop ) ) {

updateLine( event->pos() );

}

}

bool ListDnd::dropEvent( TQDropEvent * )

{

// do nothing

}

bool ListDnd::mousePressEvent( TQMouseEvent * event )

{

if ( event->button() == TQt::LeftButton )

mousePressPos = event->pos();

}

bool ListDnd::mouseMoveEvent( TQMouseEvent * )

{

// do nothing

}

void ListDnd::updateLine( const TQPoint & )

bool ListDnd::canDecode( TQDragEnterEvent * )

{

// do nothing

}

for ( TQStringList::ConstIterator it = l.begin(); it != l.end(); ++it ) {

i = new TQListViewItem( listview, i );

i->setText( 0, *it );

}

}

void ListEditor::addItem()

{

TQListViewItem *i = new TQListViewItem( listview, listview->lastItem() );

tqApp->processEvents();

i->startRename( 0 );

}

void ListViewDnd::confirmDrop( TQListViewItem * )

{

}

bool ListViewDnd::dropEvent( TQDropEvent * event )

if ( dMode & NullDrop ) { // combined with Move, a NullDrop will delete an item

event->accept();

emit dropped( 0 ); // a NullDrop

}

TQPoint pos = event->pos();

}

line->hide();

}

bool ListViewDnd::mouseMoveEvent( TQMouseEvent * event )

if ( dMode & Move ) {

disabledItems = list;

}

dragobject->dragCopy();

// Shouldn't autoDelete handle this?

for( list.first(); list.current(); list.next() )

delete list.current();

} else {

// Reenable disabled items since

// drag'n'drop was aborted

}

disabledItems.clear();

}

}

}

}

int ListViewDnd::buildFlatList( ListViewItemList & list )

{

TQListViewItem *nextSibling = 0;

TQListViewItem *nextParent = 0;

TQListViewItemIterator it = ((TQListView *)src)->firstChild();

for ( ; *it; it++ ) {

// Hit the nextSibling, turn of child processing

if ( (*it) == nextSibling )

if ( (*it)->isSelected() ) {

if ( (*it)->childCount() == 0 ) {

// Children processing not set, so set it

// Also find the item were we shall quit

// processing children...if any such item

nextSibling = (*it)->nextSibling();

nextParent = (*it)->parent();

while ( nextParent && !nextSibling ) {

for( int i = 0; i < count; i++ ) {

if ( itemParent ) {

insertPoint = new TQListViewItem( itemParent, insertPoint );

} else { // No parent for insertPoint, use TQListView

insertPoint = new TQListViewItem( parent, insertPoint );

}

stream >> *insertPoint;

}

}

}

#include <tdelocale.h>

ListViewEditor::ListViewEditor( TQWidget *parent, TQListView *lv, FormWindow *fw )

{

connect( helpButton, TQ_SIGNAL( clicked() ), MainWindow::self, TQ_SLOT( showDialogHelp() ) );

setupColumns();

PopulateListViewCommand::transferItems( listview, itemsPreview );

if ( itemsPreview->firstChild() ) {

itemsPreview->setCurrentItem( itemsPreview->firstChild() );

}

// Clamp on drag and drop to TQListView

// Enable rename for all TQListViewItems

TQListViewItemIterator it = ((TQListView *)itemsPreview)->firstChild();

for ( ; *it; it++ )

// Connect listview signal to signal-relay

TQObject::connect( itemsPreview,

colPreview->insertItem( i, below );

colPreview->setCurrentItem( i );