/****************************************************************************
** Form implementation generated from reading ui file 'customwidgeteditor.ui'
**
** Created by: The TQt user interface compiler (TQt 3.5.0)
**
** WARNING! All changes made in this file will be lost!
****************************************************************************/

#include "customwidgeteditor.h"

#include <ntqvariant.h>
#include <ntqpushbutton.h>
#include <ntqlistbox.h>
#include <ntqtabwidget.h>
#include <ntqwidget.h>
#include <ntqlabel.h>
#include <ntqlineedit.h>
#include <ntqcombobox.h>
#include <ntqspinbox.h>
#include <ntqcheckbox.h>
#include <ntqheader.h>
#include <ntqlistview.h>
#include <ntqlayout.h>
#include <ntqtooltip.h>
#include <ntqwhatsthis.h>

/*
 *  Constructs a CustomWidgetEditorBase as a child of 'parent', with the
 *  name 'name' and widget flags set to 'f'.
 *
 *  The qdialog will by default be modeless, unless you set 'modal' to
 *  true to construct a modal qdialog.
 */
CustomWidgetEditorBase::CustomWidgetEditorBase( TQWidget* parent, const char* name, bool modal, WFlags fl )
    : TQDialog( parent, name, modal, fl )
{
    if ( !name )
	setName( "CustomWidgetEditorBase" );
    setSizeGripEnabled( true );
    CustomWidgetEditorBaseLayout = new TQGridLayout( this, 1, 1, 11, 6, "CustomWidgetEditorBaseLayout"); 

    boxWidgets = new TQListBox( this, "boxWidgets" );

    CustomWidgetEditorBaseLayout->addMultiCellWidget( boxWidgets, 0, 4, 0, 0 );

    buttonNewWidget = new TQPushButton( this, "buttonNewWidget" );

    CustomWidgetEditorBaseLayout->addWidget( buttonNewWidget, 0, 1 );

    buttonDeleteWidget = new TQPushButton( this, "buttonDeleteWidget" );

    CustomWidgetEditorBaseLayout->addWidget( buttonDeleteWidget, 1, 1 );

    Layout1 = new TQHBoxLayout( 0, 0, 6, "Layout1"); 

    helpButton = new TQPushButton( this, "helpButton" );
    helpButton->setAutoDefault( true );
    Layout1->addWidget( helpButton );
    Horizontal_Spacing2 = new TQSpacerItem( 20, 20, TQSizePolicy::Expanding, TQSizePolicy::Minimum );
    Layout1->addItem( Horizontal_Spacing2 );

    buttonCancel = new TQPushButton( this, "buttonCancel" );
    buttonCancel->setAutoDefault( true );
    Layout1->addWidget( buttonCancel );

    CustomWidgetEditorBaseLayout->addMultiCellLayout( Layout1, 5, 5, 0, 2 );
    Vertical_Spacing1 = new TQSpacerItem( 20, 20, TQSizePolicy::Minimum, TQSizePolicy::Expanding );
    CustomWidgetEditorBaseLayout->addItem( Vertical_Spacing1, 2, 1 );

    buttonLoad = new TQPushButton( this, "buttonLoad" );

    CustomWidgetEditorBaseLayout->addWidget( buttonLoad, 3, 1 );

    buttonSave = new TQPushButton( this, "buttonSave" );

    CustomWidgetEditorBaseLayout->addWidget( buttonSave, 4, 1 );

    TabWidget1 = new TQTabWidget( this, "TabWidget1" );

    Widget2 = new TQWidget( TabWidget1, "Widget2" );
    Widget2Layout = new TQGridLayout( Widget2, 1, 1, 11, 6, "Widget2Layout"); 

    Layout4 = new TQHBoxLayout( 0, 0, 6, "Layout4"); 

    previewPixmap = new TQLabel( Widget2, "previewPixmap" );
    Layout4->addWidget( previewPixmap );

    buttonChoosePixmap = new TQPushButton( Widget2, "buttonChoosePixmap" );
    buttonChoosePixmap->setMaximumSize( TQSize( 30, 22 ) );
    Layout4->addWidget( buttonChoosePixmap );

    Widget2Layout->addMultiCellLayout( Layout4, 2, 2, 1, 2 );

    Layout5 = new TQHBoxLayout( 0, 0, 6, "Layout5"); 

    editHeader = new TQLineEdit( Widget2, "editHeader" );
    Layout5->addWidget( editHeader );

    buttonChooseHeader = new TQPushButton( Widget2, "buttonChooseHeader" );
    buttonChooseHeader->setMaximumSize( TQSize( 30, 22 ) );
    Layout5->addWidget( buttonChooseHeader );

    localGlobalCombo = new TQComboBox( false, Widget2, "localGlobalCombo" );
    Layout5->addWidget( localGlobalCombo );

    Widget2Layout->addMultiCellLayout( Layout5, 1, 1, 1, 2 );

    editClass = new TQLineEdit( Widget2, "editClass" );

    Widget2Layout->addMultiCellWidget( editClass, 0, 0, 1, 2 );

    Label11 = new TQLabel( Widget2, "Label11" );

    Widget2Layout->addWidget( Label11, 1, 0 );

    Label10 = new TQLabel( Widget2, "Label10" );

    Widget2Layout->addWidget( Label10, 0, 0 );

    Label2 = new TQLabel( Widget2, "Label2" );

    Widget2Layout->addWidget( Label2, 2, 0 );

    Label7 = new TQLabel( Widget2, "Label7" );

    Widget2Layout->addWidget( Label7, 3, 0 );

    TextLabel1_2 = new TQLabel( Widget2, "TextLabel1_2" );

    Widget2Layout->addWidget( TextLabel1_2, 4, 0 );

    sizeVer = new TQComboBox( false, Widget2, "sizeVer" );

    Widget2Layout->addWidget( sizeVer, 4, 2 );

    spinWidth = new TQSpinBox( Widget2, "spinWidth" );
    spinWidth->setMaxValue( 32767 );
    spinWidth->setMinValue( -1 );
    spinWidth->setValue( -1 );

    Widget2Layout->addWidget( spinWidth, 3, 1 );

    spinHeight = new TQSpinBox( Widget2, "spinHeight" );
    spinHeight->setMaxValue( 32767 );
    spinHeight->setMinValue( -1 );
    spinHeight->setValue( -1 );

    Widget2Layout->addWidget( spinHeight, 3, 2 );

    sizeHor = new TQComboBox( false, Widget2, "sizeHor" );

    Widget2Layout->addWidget( sizeHor, 4, 1 );
    Spacer1 = new TQSpacerItem( 20, 20, TQSizePolicy::Minimum, TQSizePolicy::Expanding );
    Widget2Layout->addItem( Spacer1, 6, 2 );

    checkContainer = new TQCheckBox( Widget2, "checkContainer" );

    Widget2Layout->addWidget( checkContainer, 5, 1 );
    TabWidget1->insertTab( Widget2, TQString::fromLatin1("") );

    Widget3 = new TQWidget( TabWidget1, "Widget3" );
    Widget3Layout = new TQVBoxLayout( Widget3, 11, 6, "Widget3Layout"); 

    listSignals = new TQListBox( Widget3, "listSignals" );
    Widget3Layout->addWidget( listSignals );

    Layout40 = new TQHBoxLayout( 0, 0, 6, "Layout40"); 
    Spacer1_2 = new TQSpacerItem( 20, 20, TQSizePolicy::Expanding, TQSizePolicy::Minimum );
    Layout40->addItem( Spacer1_2 );

    buttonAddSignal = new TQPushButton( Widget3, "buttonAddSignal" );
    buttonAddSignal->setAutoDefault( true );
    Layout40->addWidget( buttonAddSignal );

    buttonRemoveSignal = new TQPushButton( Widget3, "buttonRemoveSignal" );
    buttonRemoveSignal->setAutoDefault( true );
    Layout40->addWidget( buttonRemoveSignal );
    Widget3Layout->addLayout( Layout40 );

    Layout38 = new TQHBoxLayout( 0, 0, 6, "Layout38"); 

    TextLabel1 = new TQLabel( Widget3, "TextLabel1" );
    Layout38->addWidget( TextLabel1 );

    editSignal = new TQLineEdit( Widget3, "editSignal" );
    Layout38->addWidget( editSignal );
    Widget3Layout->addLayout( Layout38 );
    TabWidget1->insertTab( Widget3, TQString::fromLatin1("") );

    Widget4 = new TQWidget( TabWidget1, "Widget4" );
    Widget4Layout = new TQGridLayout( Widget4, 1, 1, 11, 6, "Widget4Layout"); 

    listSlots = new TQListView( Widget4, "listSlots" );
    listSlots->addColumn( tr( "Slot" ) );
    listSlots->addColumn( tr( "Access" ) );
    listSlots->setAllColumnsShowFocus( true );
    listSlots->setShowSortIndicator( true );

    Widget4Layout->addMultiCellWidget( listSlots, 0, 0, 0, 3 );

    TextLabel2 = new TQLabel( Widget4, "TextLabel2" );

    Widget4Layout->addWidget( TextLabel2, 2, 0 );

    editSlot = new TQLineEdit( Widget4, "editSlot" );

    Widget4Layout->addWidget( editSlot, 2, 1 );

    TextLabel3 = new TQLabel( Widget4, "TextLabel3" );

    Widget4Layout->addWidget( TextLabel3, 2, 2 );

    comboAccess = new TQComboBox( false, Widget4, "comboAccess" );

    Widget4Layout->addWidget( comboAccess, 2, 3 );

    Layout7 = new TQHBoxLayout( 0, 0, 6, "Layout7"); 
    Spacer2 = new TQSpacerItem( 20, 20, TQSizePolicy::Expanding, TQSizePolicy::Minimum );
    Layout7->addItem( Spacer2 );

    buttonAddSlot = new TQPushButton( Widget4, "buttonAddSlot" );
    buttonAddSlot->setAutoDefault( true );
    Layout7->addWidget( buttonAddSlot );

    buttonRemoveSlot = new TQPushButton( Widget4, "buttonRemoveSlot" );
    buttonRemoveSlot->setAutoDefault( true );
    Layout7->addWidget( buttonRemoveSlot );

    Widget4Layout->addMultiCellLayout( Layout7, 1, 1, 0, 3 );
    TabWidget1->insertTab( Widget4, TQString::fromLatin1("") );

    Widget5 = new TQWidget( TabWidget1, "Widget5" );
    Widget5Layout = new TQGridLayout( Widget5, 1, 1, 11, 6, "Widget5Layout"); 

    Layout7_2 = new TQHBoxLayout( 0, 0, 6, "Layout7_2"); 
    Spacer2_2 = new TQSpacerItem( 20, 20, TQSizePolicy::Expanding, TQSizePolicy::Minimum );
    Layout7_2->addItem( Spacer2_2 );

    buttonAddProperty = new TQPushButton( Widget5, "buttonAddProperty" );
    buttonAddProperty->setAutoDefault( true );
    Layout7_2->addWidget( buttonAddProperty );

    buttonRemoveProperty = new TQPushButton( Widget5, "buttonRemoveProperty" );
    buttonRemoveProperty->setAutoDefault( true );
    Layout7_2->addWidget( buttonRemoveProperty );

    Widget5Layout->addMultiCellLayout( Layout7_2, 1, 1, 0, 3 );

    comboType = new TQComboBox( false, Widget5, "comboType" );

    Widget5Layout->addWidget( comboType, 2, 3 );

    listProperties = new TQListView( Widget5, "listProperties" );
    listProperties->addColumn( tr( "Property" ) );
    listProperties->addColumn( tr( "Type" ) );
    listProperties->setAllColumnsShowFocus( true );
    listProperties->setShowSortIndicator( true );

    Widget5Layout->addMultiCellWidget( listProperties, 0, 0, 0, 3 );

    editProperty = new TQLineEdit( Widget5, "editProperty" );

    Widget5Layout->addWidget( editProperty, 2, 1 );

    TextLabel2_2 = new TQLabel( Widget5, "TextLabel2_2" );

    Widget5Layout->addWidget( TextLabel2_2, 2, 0 );

    TextLabel3_2 = new TQLabel( Widget5, "TextLabel3_2" );

    Widget5Layout->addWidget( TextLabel3_2, 2, 2 );
    TabWidget1->insertTab( Widget5, TQString::fromLatin1("") );

    CustomWidgetEditorBaseLayout->addMultiCellWidget( TabWidget1, 0, 4, 2, 2 );
    languageChange();
    resize( TQSize(712, 386).expandedTo(minimumSizeHint()) );
    clearWState( WState_Polished );

    // signals and slots connections
    connect( boxWidgets, TQ_SIGNAL( selectionChanged(TQListBoxItem*) ), this, TQ_SLOT( currentWidgetChanged(TQListBoxItem*) ) );
    connect( boxWidgets, TQ_SIGNAL( currentChanged(TQListBoxItem*) ), this, TQ_SLOT( currentWidgetChanged(TQListBoxItem*) ) );
    connect( buttonNewWidget, TQ_SIGNAL( clicked() ), this, TQ_SLOT( addWidgetClicked() ) );
    connect( buttonDeleteWidget, TQ_SIGNAL( clicked() ), this, TQ_SLOT( deleteWidgetClicked() ) );
    connect( editClass, TQ_SIGNAL( textChanged(const TQString&) ), this, TQ_SLOT( classNameChanged(const TQString&) ) );
    connect( editHeader, TQ_SIGNAL( textChanged(const TQString&) ), this, TQ_SLOT( headerFileChanged(const TQString&) ) );
    connect( spinWidth, TQ_SIGNAL( valueChanged(int) ), this, TQ_SLOT( widthChanged(int) ) );
    connect( spinHeight, TQ_SIGNAL( valueChanged(int) ), this, TQ_SLOT( heightChanged(int) ) );
    connect( buttonChoosePixmap, TQ_SIGNAL( clicked() ), this, TQ_SLOT( pixmapChoosen() ) );
    connect( localGlobalCombo, TQ_SIGNAL( highlighted(int) ), this, TQ_SLOT( includePolicyChanged(int) ) );
    connect( buttonChooseHeader, TQ_SIGNAL( clicked() ), this, TQ_SLOT( chooseHeader() ) );
    connect( buttonCancel, TQ_SIGNAL( clicked() ), this, TQ_SLOT( closeClicked() ) );
    connect( listSignals, TQ_SIGNAL( currentChanged(TQListBoxItem*) ), this, TQ_SLOT( currentSignalChanged(TQListBoxItem*) ) );
    connect( listSignals, TQ_SIGNAL( selectionChanged(TQListBoxItem*) ), this, TQ_SLOT( currentSignalChanged(TQListBoxItem*) ) );
    connect( buttonRemoveSignal, TQ_SIGNAL( clicked() ), this, TQ_SLOT( removeSignal() ) );
    connect( editSignal, TQ_SIGNAL( textChanged(const TQString&) ), this, TQ_SLOT( signalNameChanged(const TQString&) ) );
    connect( listSlots, TQ_SIGNAL( currentChanged(TQListViewItem*) ), this, TQ_SLOT( currentSlotChanged(TQListViewItem*) ) );
    connect( listSlots, TQ_SIGNAL( selectionChanged(TQListViewItem*) ), this, TQ_SLOT( currentSlotChanged(TQListViewItem*) ) );
    connect( buttonRemoveSlot, TQ_SIGNAL( clicked() ), this, TQ_SLOT( removeSlot() ) );
    connect( editSlot, TQ_SIGNAL( textChanged(const TQString&) ), this, TQ_SLOT( slotNameChanged(const TQString&) ) );
    connect( comboAccess, TQ_SIGNAL( activated(const TQString&) ), this, TQ_SLOT( slotAccessChanged(const TQString&) ) );
    connect( listProperties, TQ_SIGNAL( currentChanged(TQListViewItem*) ), this, TQ_SLOT( currentPropertyChanged(TQListViewItem*) ) );
    connect( listProperties, TQ_SIGNAL( selectionChanged(TQListViewItem*) ), this, TQ_SLOT( currentPropertyChanged(TQListViewItem*) ) );
    connect( buttonRemoveProperty, TQ_SIGNAL( clicked() ), this, TQ_SLOT( removeProperty() ) );
    connect( editProperty, TQ_SIGNAL( textChanged(const TQString&) ), this, TQ_SLOT( propertyNameChanged(const TQString&) ) );
    connect( comboType, TQ_SIGNAL( activated(const TQString&) ), this, TQ_SLOT( propertyTypeChanged(const TQString&) ) );
    connect( buttonLoad, TQ_SIGNAL( clicked() ), this, TQ_SLOT( loadDescription() ) );
    connect( buttonSave, TQ_SIGNAL( clicked() ), this, TQ_SLOT( saveDescription() ) );
    connect( sizeHor, TQ_SIGNAL( activated(int) ), this, TQ_SLOT( horDataChanged(int) ) );
    connect( sizeVer, TQ_SIGNAL( activated(int) ), this, TQ_SLOT( verDataChanged(int) ) );
    connect( buttonAddProperty, TQ_SIGNAL( clicked() ), this, TQ_SLOT( addProperty() ) );
    connect( checkContainer, TQ_SIGNAL( toggled(bool) ), this, TQ_SLOT( widgetIsContainer(bool) ) );
    connect( buttonAddSignal, TQ_SIGNAL( clicked() ), this, TQ_SLOT( addSignal() ) );
    connect( buttonAddSlot, TQ_SIGNAL( clicked() ), this, TQ_SLOT( addSlot() ) );

    // tab order
    setTabOrder( buttonCancel, boxWidgets );
    setTabOrder( boxWidgets, buttonNewWidget );
    setTabOrder( buttonNewWidget, buttonDeleteWidget );
    setTabOrder( buttonDeleteWidget, buttonLoad );
    setTabOrder( buttonLoad, buttonSave );
    setTabOrder( buttonSave, TabWidget1 );
    setTabOrder( TabWidget1, editClass );
    setTabOrder( editClass, editHeader );
    setTabOrder( editHeader, buttonChooseHeader );
    setTabOrder( buttonChooseHeader, localGlobalCombo );
    setTabOrder( localGlobalCombo, buttonChoosePixmap );
    setTabOrder( buttonChoosePixmap, spinWidth );
    setTabOrder( spinWidth, spinHeight );
    setTabOrder( spinHeight, sizeHor );
    setTabOrder( sizeHor, sizeVer );
    setTabOrder( sizeVer, checkContainer );
    setTabOrder( checkContainer, helpButton );
    setTabOrder( helpButton, listSignals );
    setTabOrder( listSignals, buttonAddSignal );
    setTabOrder( buttonAddSignal, buttonRemoveSignal );
    setTabOrder( buttonRemoveSignal, editSignal );
    setTabOrder( editSignal, listSlots );
    setTabOrder( listSlots, buttonAddSlot );
    setTabOrder( buttonAddSlot, buttonRemoveSlot );
    setTabOrder( buttonRemoveSlot, editSlot );
    setTabOrder( editSlot, comboAccess );
    setTabOrder( comboAccess, listProperties );
    setTabOrder( listProperties, buttonAddProperty );
    setTabOrder( buttonAddProperty, buttonRemoveProperty );
    setTabOrder( buttonRemoveProperty, editProperty );
    setTabOrder( editProperty, comboType );

    // buddies
    Label11->setBuddy( editHeader );
    Label10->setBuddy( editClass );
    Label7->setBuddy( spinWidth );
    TextLabel1_2->setBuddy( sizeHor );
    TextLabel1->setBuddy( editSignal );
    TextLabel2->setBuddy( editSlot );
    TextLabel3->setBuddy( comboAccess );
    TextLabel2_2->setBuddy( editProperty );
    TextLabel3_2->setBuddy( comboType );
    init();
}

/*
 *  Destroys the object and frees any allocated resources
 */
CustomWidgetEditorBase::~CustomWidgetEditorBase()
{
    destroy();
    // no need to delete child widgets, TQt does it all for us
}

/*
 *  Sets the strings of the subwidgets using the current
 *  language.
 */
void CustomWidgetEditorBase::languageChange()
{
    setCaption( tr( "Edit Custom Widgets" ) );
    TQWhatsThis::add( this, tr( "<b>Edit Custom Widgets</b><p>Add or delete custom widgets from <i>TQt Designer</i>'s database, and edit the properties of existing widgets.</p>" ) );
    TQWhatsThis::add( boxWidgets, tr( "The list of all custom widgets known to TQt Designer." ) );
    buttonNewWidget->setText( tr( "&New Widget" ) );
    TQToolTip::add( buttonNewWidget, tr( "Add new custom widget." ) );
    TQWhatsThis::add( buttonNewWidget, tr( "<b>Create an empty custom widget and add it to the list.</b><p>New custom widgets have a default name and header file, which must both be changed to appropriate values.</p>" ) );
    buttonDeleteWidget->setText( tr( "&Delete Widget" ) );
    TQToolTip::add( buttonDeleteWidget, tr( "Delete custom widget" ) );
    TQWhatsThis::add( buttonDeleteWidget, tr( "<b>Delete the selected custom widget.</b><p>You can only delete widgets that are not used in any open form.</p>" ) );
    helpButton->setText( tr( "&Help" ) );
    buttonCancel->setText( tr( "&Close" ) );
    TQWhatsThis::add( buttonCancel, tr( "Closes the Dialog." ) );
    buttonLoad->setText( tr( "&Load Descriptions..." ) );
    TQToolTip::add( buttonLoad, tr( "Loads widget description file" ) );
    TQWhatsThis::add( buttonLoad, tr( "<b>Load Descriptions</b><p>Loads a file which contains descriptions of custom widgets, so that these custom widgets can be used in the TQt Designer.</p>\n"
"<p>Since it is a lot of work to type in all the information for custom widgets, you should consider using the tqtcreatecw tool which is in $TQTDIR/tools/designer/tools/tqtcreatecw. Using tqtcreatecw you can create custom widget description files for your custom widgets without the need to type in all the information manually. For more information about the README file in the tqtcreatecw directory</p>" ) );
    buttonSave->setText( tr( "&Save Descriptions..." ) );
    TQToolTip::add( buttonSave, tr( "Saves widget description file" ) );
    TQWhatsThis::add( buttonSave, tr( "<b>Save Descriptions</b><p>Saves all the descriptions of the shown custom widgets to a file which can then be used to import the custom widgets elsewhere." ) );
    TQWhatsThis::add( TabWidget1, tr( "Change the properties of the selected custom widget." ) );
    previewPixmap->setText( TQString::null );
    buttonChoosePixmap->setText( tr( "..." ) );
    TQToolTip::add( buttonChoosePixmap, tr( "Select a Pixmap" ) );
    TQWhatsThis::add( buttonChoosePixmap, tr( "<b>Select a pixmap file.</b><p>The pixmap will be used to represent the widget in forms.</b>" ) );
    TQToolTip::add( editHeader, tr( "Enter filename" ) );
    TQWhatsThis::add( editHeader, tr( "<b>Change the header file's name for the selected custom widget.</b><p>The header file will be included by forms using the widget.</p>" ) );
    buttonChooseHeader->setText( tr( "..." ) );
    TQToolTip::add( buttonChooseHeader, tr( "Choose headerfile" ) );
    TQWhatsThis::add( buttonChooseHeader, tr( "Look for the header file using a filedialog." ) );
    localGlobalCombo->clear();
    localGlobalCombo->insertItem( tr( "Global" ) );
    localGlobalCombo->insertItem( tr( "Local" ) );
    TQToolTip::add( localGlobalCombo, tr( "Select access" ) );
    TQWhatsThis::add( localGlobalCombo, tr( "<b>Change how the include file will be included.</b><p>Global include files will be included using &lt;&gt;-brackets, while local files will included using quotation marks.</p>" ) );
    TQToolTip::add( editClass, tr( "Change classname" ) );
    TQWhatsThis::add( editClass, tr( "<b>Enter the classname for the selected custom widget.</b><p>A class of that name must be defined in the header file.</p>" ) );
    Label11->setText( tr( "Heade&rfile:" ) );
    Label10->setText( tr( "Cl&ass:" ) );
    Label2->setText( tr( "Pixmap:" ) );
    Label7->setText( tr( "Si&ze Hint:" ) );
    TextLabel1_2->setText( tr( "Size P&olicy" ) );
    sizeVer->clear();
    sizeVer->insertItem( tr( "Fixed" ) );
    sizeVer->insertItem( tr( "Minimum" ) );
    sizeVer->insertItem( tr( "Maximum" ) );
    sizeVer->insertItem( tr( "Preferred" ) );
    sizeVer->insertItem( tr( "MinimumExpanding" ) );
    sizeVer->insertItem( tr( "Expanding" ) );
    TQToolTip::add( sizeVer, tr( "Vertical Sizepolicy" ) );
    TQWhatsThis::add( sizeVer, tr( "Choose the Vertical size policy" ) );
    TQToolTip::add( spinWidth, tr( "Size hint width" ) );
    TQWhatsThis::add( spinWidth, tr( "<b>Set the size hint for the selected widget.</b><p>The size hint provides the recommended size for the widget. Enter a sizehint of -1/-1 if no size is recommended.</p>" ) );
    TQToolTip::add( spinHeight, tr( "Size hint height" ) );
    TQWhatsThis::add( spinHeight, tr( "<b>Set the size hint for the selected widget.</b><p>The size hint provides the recommended size for the widget. Enter a sizehint of -1/-1 if no size is recommended.</p>" ) );
    sizeHor->clear();
    sizeHor->insertItem( tr( "Fixed" ) );
    sizeHor->insertItem( tr( "Minimum" ) );
    sizeHor->insertItem( tr( "Maximum" ) );
    sizeHor->insertItem( tr( "Preferred" ) );
    sizeHor->insertItem( tr( "MinimumExpanding" ) );
    sizeHor->insertItem( tr( "Expanding" ) );
    TQToolTip::add( sizeHor, tr( "Horizontal Sizepolicy" ) );
    TQWhatsThis::add( sizeHor, tr( "Choose the horizontal size policy for the widget" ) );
    checkContainer->setText( tr( "Con&tainer Widget" ) );
    TQToolTip::add( checkContainer, tr( "Container Widget" ) );
    TQWhatsThis::add( checkContainer, tr( "<p><b>Container Widget</b></p>\n"
"<p>If this custom widget is able to contain other widgets (children), check this checkbox.</p>" ) );
    TabWidget1->changeTab( Widget2, tr( "De&finition" ) );
    TQWhatsThis::add( listSignals, tr( "The list of all the signals that the selected widget can emit." ) );
    buttonAddSignal->setText( tr( "N&ew Signal" ) );
    TQToolTip::add( buttonAddSignal, tr( "Add new signal" ) );
    TQWhatsThis::add( buttonAddSignal, tr( "<b>Add a new signal for the current custom widget.</b><p>An argument list should be provided in the signal's name, and the name must be unique.</p>" ) );
    buttonRemoveSignal->setText( tr( "Dele&te Signal" ) );
    TQToolTip::add( buttonRemoveSignal, tr( "Delete signal" ) );
    TQWhatsThis::add( buttonRemoveSignal, tr( "<b>Delete the signal.</b><p>All connections using this signal will also be deleted.</p>" ) );
    TextLabel1->setText( tr( "S&ignal:" ) );
    TQToolTip::add( editSignal, tr( "Change signal name" ) );
    TQWhatsThis::add( editSignal, tr( "<b>Change the name of the selected slot.</b><p>An argument list should be provided in the signal's name, and the name must be unique.</p>" ) );
    TabWidget1->changeTab( Widget3, tr( "Si&gnals" ) );
    listSlots->header()->setLabel( 0, tr( "Slot" ) );
    listSlots->header()->setLabel( 1, tr( "Access" ) );
    TQWhatsThis::add( listSlots, tr( "The list of all the custom widget's slots." ) );
    TextLabel2->setText( tr( "Sl&ot:" ) );
    TQToolTip::add( editSlot, tr( "Change slot name" ) );
    TQWhatsThis::add( editSlot, tr( "<b>Change the name of the selected slot.</b><p>An argument list should be provided in the signal's name, and the name must be unique.</p>" ) );
    TextLabel3->setText( tr( "&Access:" ) );
    comboAccess->clear();
    comboAccess->insertItem( tr( "public" ) );
    comboAccess->insertItem( tr( "protected" ) );
    TQToolTip::add( comboAccess, tr( "Change slot access" ) );
    TQWhatsThis::add( comboAccess, tr( "<b>Change the slot's access policy.</b><p>You can only connect to the widget's public slots.</p>" ) );
    buttonAddSlot->setText( tr( "N&ew Slot" ) );
    TQToolTip::add( buttonAddSlot, tr( "Add new slot" ) );
    TQWhatsThis::add( buttonAddSlot, tr( "<b>Add a new slot to the current custom widget.</b><p>An argument list should be provided in the signal's name, and the name must be unique.</p>" ) );
    buttonRemoveSlot->setText( tr( "Dele&te Slot" ) );
    TQToolTip::add( buttonRemoveSlot, tr( "Delete slot" ) );
    TQWhatsThis::add( buttonRemoveSlot, tr( "<b>Delete the slot.</b><p>All connections using this slot will also be deleted.</p>" ) );
    TabWidget1->changeTab( Widget4, tr( "S&lots" ) );
    buttonAddProperty->setText( tr( "N&ew Property" ) );
    TQToolTip::add( buttonAddProperty, tr( "Add new property" ) );
    TQWhatsThis::add( buttonAddProperty, tr( "<b>Add a new property to the current custom widget.</b><p>The properties must be implemented in the class using TQt's property system.</p>" ) );
    buttonRemoveProperty->setText( tr( "Dele&te Property" ) );
    TQToolTip::add( buttonRemoveProperty, tr( "Delete property" ) );
    TQWhatsThis::add( buttonRemoveProperty, tr( "Deletes the selected property." ) );
    comboType->clear();
    comboType->insertItem( tr( "String" ) );
    comboType->insertItem( tr( "CString" ) );
    comboType->insertItem( tr( "StringList" ) );
    comboType->insertItem( tr( "Bool" ) );
    comboType->insertItem( tr( "Int" ) );
    comboType->insertItem( tr( "UInt" ) );
    comboType->insertItem( tr( "Font" ) );
    comboType->insertItem( tr( "Color" ) );
    comboType->insertItem( tr( "Rect" ) );
    comboType->insertItem( tr( "Point" ) );
    comboType->insertItem( tr( "Size" ) );
    comboType->insertItem( tr( "Pixmap" ) );
    comboType->insertItem( tr( "Palette" ) );
    comboType->insertItem( tr( "Cursor" ) );
    comboType->insertItem( tr( "SizePolicy" ) );
    TQToolTip::add( comboType, tr( "Select property type" ) );
    TQWhatsThis::add( comboType, tr( "<b>Select the type of the property.</b><p>The propertiy must be implemented in the class using TQt's property system.</p><p>You can use integer types to support enumeration properties in the property editor.</p>" ) );
    listProperties->header()->setLabel( 0, tr( "Property" ) );
    listProperties->header()->setLabel( 1, tr( "Type" ) );
    TQWhatsThis::add( listProperties, tr( "<b>The list of the current widget's properties.</b><p>The properties of the custom widget can be changed in the property editor.</p>" ) );
    TQToolTip::add( editProperty, tr( "Change property name" ) );
    TQWhatsThis::add( editProperty, tr( "<b>Enter a name for the property.</b><p>The properties must be implemented in the class using TQt's property system.</p>" ) );
    TextLabel2_2->setText( tr( "P&roperty Name:" ) );
    TextLabel3_2->setText( tr( "T&ype:" ) );
    TabWidget1->changeTab( Widget5, tr( "&Properties" ) );
}

void CustomWidgetEditorBase::init()
{
}

void CustomWidgetEditorBase::destroy()
{
}

void CustomWidgetEditorBase::addProperty()
{
    tqWarning( "CustomWidgetEditorBase::addProperty(): Not implemented yet" );
}

void CustomWidgetEditorBase::addSignal()
{
    tqWarning( "CustomWidgetEditorBase::addSignal(): Not implemented yet" );
}

void CustomWidgetEditorBase::addWidgetClicked()
{
    tqWarning( "CustomWidgetEditorBase::addWidgetClicked(): Not implemented yet" );
}

void CustomWidgetEditorBase::chooseHeader()
{
    tqWarning( "CustomWidgetEditorBase::chooseHeader(): Not implemented yet" );
}

void CustomWidgetEditorBase::classNameChanged(const TQString&)
{
    tqWarning( "CustomWidgetEditorBase::classNameChanged(const TQString&): Not implemented yet" );
}

void CustomWidgetEditorBase::closeClicked()
{
    tqWarning( "CustomWidgetEditorBase::closeClicked(): Not implemented yet" );
}

void CustomWidgetEditorBase::currentPropertyChanged(TQListViewItem*)
{
    tqWarning( "CustomWidgetEditorBase::currentPropertyChanged(TQListViewItem*): Not implemented yet" );
}

void CustomWidgetEditorBase::currentSignalChanged(TQListBoxItem*)
{
    tqWarning( "CustomWidgetEditorBase::currentSignalChanged(TQListBoxItem*): Not implemented yet" );
}

void CustomWidgetEditorBase::currentSlotChanged(TQListViewItem*)
{
    tqWarning( "CustomWidgetEditorBase::currentSlotChanged(TQListViewItem*): Not implemented yet" );
}

void CustomWidgetEditorBase::currentWidgetChanged(TQListBoxItem*)
{
    tqWarning( "CustomWidgetEditorBase::currentWidgetChanged(TQListBoxItem*): Not implemented yet" );
}

void CustomWidgetEditorBase::deleteWidgetClicked()
{
    tqWarning( "CustomWidgetEditorBase::deleteWidgetClicked(): Not implemented yet" );
}

void CustomWidgetEditorBase::headerFileChanged(const TQString&)
{
    tqWarning( "CustomWidgetEditorBase::headerFileChanged(const TQString&): Not implemented yet" );
}

void CustomWidgetEditorBase::heightChanged(int)
{
    tqWarning( "CustomWidgetEditorBase::heightChanged(int): Not implemented yet" );
}

void CustomWidgetEditorBase::horDataChanged(int)
{
    tqWarning( "CustomWidgetEditorBase::horDataChanged(int): Not implemented yet" );
}

void CustomWidgetEditorBase::includePolicyChanged(int)
{
    tqWarning( "CustomWidgetEditorBase::includePolicyChanged(int): Not implemented yet" );
}

void CustomWidgetEditorBase::loadDescription()
{
    tqWarning( "CustomWidgetEditorBase::loadDescription(): Not implemented yet" );
}

void CustomWidgetEditorBase::addSlot()
{
    tqWarning( "CustomWidgetEditorBase::addSlot(): Not implemented yet" );
}

void CustomWidgetEditorBase::pixmapChoosen()
{
    tqWarning( "CustomWidgetEditorBase::pixmapChoosen(): Not implemented yet" );
}

void CustomWidgetEditorBase::propertyNameChanged(const TQString&)
{
    tqWarning( "CustomWidgetEditorBase::propertyNameChanged(const TQString&): Not implemented yet" );
}

void CustomWidgetEditorBase::propertyTypeChanged(const TQString&)
{
    tqWarning( "CustomWidgetEditorBase::propertyTypeChanged(const TQString&): Not implemented yet" );
}

void CustomWidgetEditorBase::removeProperty()
{
    tqWarning( "CustomWidgetEditorBase::removeProperty(): Not implemented yet" );
}

void CustomWidgetEditorBase::removeSignal()
{
    tqWarning( "CustomWidgetEditorBase::removeSignal(): Not implemented yet" );
}

void CustomWidgetEditorBase::removeSlot()
{
    tqWarning( "CustomWidgetEditorBase::removeSlot(): Not implemented yet" );
}

void CustomWidgetEditorBase::saveDescription()
{
    tqWarning( "CustomWidgetEditorBase::saveDescription(): Not implemented yet" );
}

void CustomWidgetEditorBase::signalNameChanged(const TQString&)
{
    tqWarning( "CustomWidgetEditorBase::signalNameChanged(const TQString&): Not implemented yet" );
}

void CustomWidgetEditorBase::slotAccessChanged(const TQString&)
{
    tqWarning( "CustomWidgetEditorBase::slotAccessChanged(const TQString&): Not implemented yet" );
}

void CustomWidgetEditorBase::slotNameChanged(const TQString&)
{
    tqWarning( "CustomWidgetEditorBase::slotNameChanged(const TQString&): Not implemented yet" );
}

void CustomWidgetEditorBase::verDataChanged(int)
{
    tqWarning( "CustomWidgetEditorBase::verDataChanged(int): Not implemented yet" );
}

void CustomWidgetEditorBase::widgetIsContainer(bool)
{
    tqWarning( "CustomWidgetEditorBase::widgetIsContainer(bool): Not implemented yet" );
}

void CustomWidgetEditorBase::widthChanged(int)
{
    tqWarning( "CustomWidgetEditorBase::widthChanged(int): Not implemented yet" );
}

