#include <kdialog.h>
#include <tdelocale.h>

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

#include "kmyfirewallruleeditorprotocol.h"

#include <ntqvariant.h>
#include <ntqpushbutton.h>
#include <ntqlabel.h>
#include <ntqgroupbox.h>
#include <ntqcheckbox.h>
#include <ntqtabwidget.h>
#include <ntqframe.h>
#include <ntqspinbox.h>
#include <ntqbuttongroup.h>
#include <ntqcombobox.h>
#include <ntqlayout.h>
#include <ntqtooltip.h>
#include <ntqwhatsthis.h>

/*
 *  Constructs a KMyFirewallRuleEditorProtocol as a child of 'parent', with the
 *  name 'name' and widget flags set to 'f'.
 */
KMyFirewallRuleEditorProtocol::KMyFirewallRuleEditorProtocol( TQWidget* parent, const char* name, WFlags fl )
    : TQWidget( parent, name, fl )
{
    if ( !name )
	setName( "KMyFirewallRuleEditorProtocol" );
    KMyFirewallRuleEditorProtocolLayout = new TQGridLayout( this, 1, 1, 2, 6, "KMyFirewallRuleEditorProtocolLayout"); 

    l_greeting = new TQLabel( this, "l_greeting" );
    l_greeting->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)5, (TQSizePolicy::SizeType)0, 0, 0, l_greeting->sizePolicy().hasHeightForWidth() ) );
    l_greeting->setMinimumSize( TQSize( 0, 40 ) );
    l_greeting->setMaximumSize( TQSize( 32767, 40 ) );
    TQFont l_greeting_font(  l_greeting->font() );
    l_greeting_font.setFamily( "Arial" );
    l_greeting_font.setBold( true );
    l_greeting->setFont( l_greeting_font ); 
    l_greeting->setFrameShape( TQLabel::StyledPanel );
    l_greeting->setFrameShadow( TQLabel::Plain );
    l_greeting->setLineWidth( 2 );
    l_greeting->setAlignment( int( TQLabel::WordBreak | TQLabel::AlignCenter ) );

    KMyFirewallRuleEditorProtocolLayout->addWidget( l_greeting, 0, 0 );

    gb_protocol = new TQGroupBox( this, "gb_protocol" );
    gb_protocol->setEnabled( true );
    gb_protocol->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)5, (TQSizePolicy::SizeType)0, 0, 0, gb_protocol->sizePolicy().hasHeightForWidth() ) );
    gb_protocol->setAlignment( int( TQGroupBox::WordBreak | TQGroupBox::AlignLeft ) );
    gb_protocol->setColumnLayout(0, TQt::Vertical );
    gb_protocol->layout()->setSpacing( 6 );
    gb_protocol->layout()->setMargin( 11 );
    gb_protocolLayout = new TQGridLayout( gb_protocol->layout() );
    gb_protocolLayout->setAlignment( TQt::AlignTop );

    c_all = new TQCheckBox( gb_protocol, "c_all" );
    c_all->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)1, (TQSizePolicy::SizeType)0, 0, 0, c_all->sizePolicy().hasHeightForWidth() ) );

    gb_protocolLayout->addWidget( c_all, 0, 0 );

    c_tcp = new TQCheckBox( gb_protocol, "c_tcp" );
    c_tcp->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)1, (TQSizePolicy::SizeType)0, 0, 0, c_tcp->sizePolicy().hasHeightForWidth() ) );

    gb_protocolLayout->addWidget( c_tcp, 0, 1 );

    c_inv_prot = new TQCheckBox( gb_protocol, "c_inv_prot" );
    c_inv_prot->setEnabled( false );
    c_inv_prot->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)0, (TQSizePolicy::SizeType)0, 0, 0, c_inv_prot->sizePolicy().hasHeightForWidth() ) );

    gb_protocolLayout->addWidget( c_inv_prot, 0, 4 );

    c_udp = new TQCheckBox( gb_protocol, "c_udp" );
    c_udp->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)5, (TQSizePolicy::SizeType)0, 0, 0, c_udp->sizePolicy().hasHeightForWidth() ) );

    gb_protocolLayout->addWidget( c_udp, 0, 2 );

    c_icmp = new TQCheckBox( gb_protocol, "c_icmp" );
    c_icmp->setEnabled( true );
    c_icmp->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)5, (TQSizePolicy::SizeType)0, 0, 0, c_icmp->sizePolicy().hasHeightForWidth() ) );

    gb_protocolLayout->addWidget( c_icmp, 0, 3 );

    KMyFirewallRuleEditorProtocolLayout->addWidget( gb_protocol, 1, 0 );

    tabWidget = new TQTabWidget( this, "tabWidget" );
    tabWidget->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)5, (TQSizePolicy::SizeType)5, 0, 0, tabWidget->sizePolicy().hasHeightForWidth() ) );

    tab_ports = new TQWidget( tabWidget, "tab_ports" );
    tab_portsLayout = new TQGridLayout( tab_ports, 1, 1, 11, 6, "tab_portsLayout"); 

    c_dest_port = new TQCheckBox( tab_ports, "c_dest_port" );
    c_dest_port->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)5, (TQSizePolicy::SizeType)0, 0, 0, c_dest_port->sizePolicy().hasHeightForWidth() ) );

    tab_portsLayout->addWidget( c_dest_port, 2, 0 );

    c_src_port = new TQCheckBox( tab_ports, "c_src_port" );
    c_src_port->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)5, (TQSizePolicy::SizeType)0, 0, 0, c_src_port->sizePolicy().hasHeightForWidth() ) );

    tab_portsLayout->addWidget( c_src_port, 1, 0 );

    TextLabel2_2 = new TQLabel( tab_ports, "TextLabel2_2" );
    TextLabel2_2->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)5, (TQSizePolicy::SizeType)0, 0, 0, TextLabel2_2->sizePolicy().hasHeightForWidth() ) );
    TextLabel2_2->setAlignment( int( TQLabel::WordBreak | TQLabel::AlignTop ) );

    tab_portsLayout->addMultiCellWidget( TextLabel2_2, 0, 0, 0, 1 );
    tabWidget->insertTab( tab_ports, TQString::fromLatin1("") );

    tab_multiport = new TQWidget( tabWidget, "tab_multiport" );
    tab_multiportLayout = new TQGridLayout( tab_multiport, 1, 1, 11, 6, "tab_multiportLayout"); 
    tabWidget->insertTab( tab_multiport, TQString::fromLatin1("") );

    tab_special_tcp = new TQWidget( tabWidget, "tab_special_tcp" );
    tab_special_tcpLayout = new TQGridLayout( tab_special_tcp, 1, 1, 11, 6, "tab_special_tcpLayout"); 

    gb_mask = new TQGroupBox( tab_special_tcp, "gb_mask" );
    gb_mask->setEnabled( false );
    gb_mask->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)3, (TQSizePolicy::SizeType)5, 0, 0, gb_mask->sizePolicy().hasHeightForWidth() ) );
    gb_mask->setColumnLayout(0, TQt::Vertical );
    gb_mask->layout()->setSpacing( 6 );
    gb_mask->layout()->setMargin( 5 );
    gb_maskLayout = new TQGridLayout( gb_mask->layout() );
    gb_maskLayout->setAlignment( TQt::AlignTop );

    c_all_mask = new TQCheckBox( gb_mask, "c_all_mask" );

    gb_maskLayout->addWidget( c_all_mask, 0, 0 );

    c_none_mask = new TQCheckBox( gb_mask, "c_none_mask" );

    gb_maskLayout->addWidget( c_none_mask, 0, 1 );

    c_fin_mask = new TQCheckBox( gb_mask, "c_fin_mask" );
    c_fin_mask->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)1, (TQSizePolicy::SizeType)0, 0, 0, c_fin_mask->sizePolicy().hasHeightForWidth() ) );

    gb_maskLayout->addWidget( c_fin_mask, 2, 1 );

    c_urg_mask = new TQCheckBox( gb_mask, "c_urg_mask" );
    c_urg_mask->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)1, (TQSizePolicy::SizeType)0, 0, 0, c_urg_mask->sizePolicy().hasHeightForWidth() ) );

    gb_maskLayout->addWidget( c_urg_mask, 4, 1 );

    c_psh_mask = new TQCheckBox( gb_mask, "c_psh_mask" );

    gb_maskLayout->addWidget( c_psh_mask, 4, 0 );

    c_rst_mask = new TQCheckBox( gb_mask, "c_rst_mask" );
    c_rst_mask->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)1, (TQSizePolicy::SizeType)0, 0, 0, c_rst_mask->sizePolicy().hasHeightForWidth() ) );

    gb_maskLayout->addWidget( c_rst_mask, 3, 1 );

    c_syn_mask = new TQCheckBox( gb_mask, "c_syn_mask" );

    gb_maskLayout->addWidget( c_syn_mask, 2, 0 );

    c_ack_mask = new TQCheckBox( gb_mask, "c_ack_mask" );

    gb_maskLayout->addWidget( c_ack_mask, 3, 0 );

    Line3 = new TQFrame( gb_mask, "Line3" );
    Line3->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)1, (TQSizePolicy::SizeType)0, 0, 0, Line3->sizePolicy().hasHeightForWidth() ) );
    Line3->setFrameShape( TQFrame::HLine );
    Line3->setFrameShadow( TQFrame::Sunken );
    Line3->setFrameShape( TQFrame::HLine );

    gb_maskLayout->addMultiCellWidget( Line3, 1, 1, 0, 1 );

    tab_special_tcpLayout->addWidget( gb_mask, 1, 1 );

    gb_comp = new TQGroupBox( tab_special_tcp, "gb_comp" );
    gb_comp->setEnabled( false );
    gb_comp->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)3, (TQSizePolicy::SizeType)5, 0, 0, gb_comp->sizePolicy().hasHeightForWidth() ) );
    gb_comp->setColumnLayout(0, TQt::Vertical );
    gb_comp->layout()->setSpacing( 6 );
    gb_comp->layout()->setMargin( 5 );
    gb_compLayout = new TQGridLayout( gb_comp->layout() );
    gb_compLayout->setAlignment( TQt::AlignTop );

    c_all_comp = new TQCheckBox( gb_comp, "c_all_comp" );

    gb_compLayout->addWidget( c_all_comp, 0, 0 );

    c_none_comp = new TQCheckBox( gb_comp, "c_none_comp" );

    gb_compLayout->addWidget( c_none_comp, 0, 1 );

    Line4 = new TQFrame( gb_comp, "Line4" );
    Line4->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)1, (TQSizePolicy::SizeType)0, 0, 0, Line4->sizePolicy().hasHeightForWidth() ) );
    Line4->setFrameShape( TQFrame::HLine );
    Line4->setFrameShadow( TQFrame::Sunken );
    Line4->setFrameShape( TQFrame::HLine );

    gb_compLayout->addMultiCellWidget( Line4, 1, 1, 0, 1 );

    c_syn_comp = new TQCheckBox( gb_comp, "c_syn_comp" );

    gb_compLayout->addWidget( c_syn_comp, 2, 0 );

    c_fin_comp = new TQCheckBox( gb_comp, "c_fin_comp" );
    c_fin_comp->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)1, (TQSizePolicy::SizeType)0, 0, 0, c_fin_comp->sizePolicy().hasHeightForWidth() ) );

    gb_compLayout->addWidget( c_fin_comp, 2, 1 );

    c_ack_comp = new TQCheckBox( gb_comp, "c_ack_comp" );

    gb_compLayout->addWidget( c_ack_comp, 3, 0 );

    c_rst_comp = new TQCheckBox( gb_comp, "c_rst_comp" );
    c_rst_comp->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)1, (TQSizePolicy::SizeType)0, 0, 0, c_rst_comp->sizePolicy().hasHeightForWidth() ) );

    gb_compLayout->addWidget( c_rst_comp, 3, 1 );

    c_psh_comp = new TQCheckBox( gb_comp, "c_psh_comp" );

    gb_compLayout->addWidget( c_psh_comp, 4, 0 );

    c_urg_comp = new TQCheckBox( gb_comp, "c_urg_comp" );
    c_urg_comp->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)1, (TQSizePolicy::SizeType)0, 0, 0, c_urg_comp->sizePolicy().hasHeightForWidth() ) );

    gb_compLayout->addWidget( c_urg_comp, 4, 1 );

    tab_special_tcpLayout->addWidget( gb_comp, 1, 2 );

    TextLabel4 = new TQLabel( tab_special_tcp, "TextLabel4" );
    TextLabel4->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)5, (TQSizePolicy::SizeType)5, 0, 0, TextLabel4->sizePolicy().hasHeightForWidth() ) );
    TextLabel4->setAlignment( int( TQLabel::WordBreak | TQLabel::AlignTop ) );

    tab_special_tcpLayout->addMultiCellWidget( TextLabel4, 0, 0, 1, 2 );

    layout21 = new TQGridLayout( 0, 1, 1, 0, 6, "layout21"); 

    sb_tcp_option_num = new TQSpinBox( tab_special_tcp, "sb_tcp_option_num" );
    sb_tcp_option_num->setEnabled( false );
    sb_tcp_option_num->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)5, (TQSizePolicy::SizeType)0, 0, 0, sb_tcp_option_num->sizePolicy().hasHeightForWidth() ) );

    layout21->addWidget( sb_tcp_option_num, 3, 0 );

    c_tcp_flags = new TQCheckBox( tab_special_tcp, "c_tcp_flags" );
    c_tcp_flags->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)1, (TQSizePolicy::SizeType)0, 0, 0, c_tcp_flags->sizePolicy().hasHeightForWidth() ) );

    layout21->addMultiCellWidget( c_tcp_flags, 0, 0, 0, 1 );

    c_inv_flags = new TQCheckBox( tab_special_tcp, "c_inv_flags" );
    c_inv_flags->setEnabled( false );
    c_inv_flags->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)1, (TQSizePolicy::SizeType)0, 0, 0, c_inv_flags->sizePolicy().hasHeightForWidth() ) );

    layout21->addWidget( c_inv_flags, 1, 1 );

    c_tcp_syn = new TQCheckBox( tab_special_tcp, "c_tcp_syn" );
    c_tcp_syn->setEnabled( false );
    c_tcp_syn->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)5, (TQSizePolicy::SizeType)0, 0, 0, c_tcp_syn->sizePolicy().hasHeightForWidth() ) );

    layout21->addMultiCellWidget( c_tcp_syn, 4, 4, 0, 1 );

    c_inv_tcp_option = new TQCheckBox( tab_special_tcp, "c_inv_tcp_option" );
    c_inv_tcp_option->setEnabled( false );
    c_inv_tcp_option->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)0, (TQSizePolicy::SizeType)0, 0, 0, c_inv_tcp_option->sizePolicy().hasHeightForWidth() ) );

    layout21->addWidget( c_inv_tcp_option, 3, 1 );
    Spacer10 = new TQSpacerItem( 48, 20, TQSizePolicy::Preferred, TQSizePolicy::Minimum );
    layout21->addItem( Spacer10, 1, 0 );

    c_inv_syn = new TQCheckBox( tab_special_tcp, "c_inv_syn" );
    c_inv_syn->setEnabled( false );
    c_inv_syn->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)0, (TQSizePolicy::SizeType)0, 0, 0, c_inv_syn->sizePolicy().hasHeightForWidth() ) );

    layout21->addWidget( c_inv_syn, 5, 1 );

    c_tcp_option = new TQCheckBox( tab_special_tcp, "c_tcp_option" );
    c_tcp_option->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)5, (TQSizePolicy::SizeType)0, 0, 0, c_tcp_option->sizePolicy().hasHeightForWidth() ) );

    layout21->addMultiCellWidget( c_tcp_option, 2, 2, 0, 1 );
    Spacer12 = new TQSpacerItem( 48, 16, TQSizePolicy::Preferred, TQSizePolicy::Minimum );
    layout21->addItem( Spacer12, 5, 0 );

    tab_special_tcpLayout->addMultiCellLayout( layout21, 0, 1, 0, 0 );
    tabWidget->insertTab( tab_special_tcp, TQString::fromLatin1("") );

    tab_icmp = new TQWidget( tabWidget, "tab_icmp" );
    tab_icmpLayout = new TQGridLayout( tab_icmp, 1, 1, 11, 6, "tab_icmpLayout"); 

    ButtonGroup1 = new TQButtonGroup( tab_icmp, "ButtonGroup1" );
    ButtonGroup1->setLineWidth( 0 );
    ButtonGroup1->setColumnLayout(0, TQt::Vertical );
    ButtonGroup1->layout()->setSpacing( 2 );
    ButtonGroup1->layout()->setMargin( 2 );
    ButtonGroup1Layout = new TQGridLayout( ButtonGroup1->layout() );
    ButtonGroup1Layout->setAlignment( TQt::AlignTop );

    cb_icmp_type = new TQComboBox( false, ButtonGroup1, "cb_icmp_type" );
    cb_icmp_type->setEnabled( false );
    cb_icmp_type->setEditable( true );
    cb_icmp_type->setInsertionPolicy( TQComboBox::NoInsertion );
    cb_icmp_type->setDuplicatesEnabled( false );

    ButtonGroup1Layout->addWidget( cb_icmp_type, 0, 1 );

    c_inv_icmp = new TQCheckBox( ButtonGroup1, "c_inv_icmp" );
    c_inv_icmp->setEnabled( false );
    c_inv_icmp->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)0, (TQSizePolicy::SizeType)0, 0, 0, c_inv_icmp->sizePolicy().hasHeightForWidth() ) );

    ButtonGroup1Layout->addWidget( c_inv_icmp, 1, 0 );

    c_icmp_type = new TQCheckBox( ButtonGroup1, "c_icmp_type" );
    c_icmp_type->setEnabled( false );

    ButtonGroup1Layout->addWidget( c_icmp_type, 0, 0 );

    tab_icmpLayout->addWidget( ButtonGroup1, 0, 1 );

    textLabel1 = new TQLabel( tab_icmp, "textLabel1" );
    textLabel1->setAlignment( int( TQLabel::WordBreak | TQLabel::AlignTop ) );

    tab_icmpLayout->addWidget( textLabel1, 0, 0 );
    tabWidget->insertTab( tab_icmp, TQString::fromLatin1("") );

    KMyFirewallRuleEditorProtocolLayout->addWidget( tabWidget, 2, 0 );

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

    b_ok_2 = new TQPushButton( this, "b_ok_2" );
    layout16->addWidget( b_ok_2 );
    Spacer3_2_2 = new TQSpacerItem( 140, 20, TQSizePolicy::Preferred, TQSizePolicy::Minimum );
    layout16->addItem( Spacer3_2_2 );

    b_help = new TQPushButton( this, "b_help" );
    layout16->addWidget( b_help );
    Spacer3_2 = new TQSpacerItem( 140, 20, TQSizePolicy::Preferred, TQSizePolicy::Minimum );
    layout16->addItem( Spacer3_2 );

    b_ok = new TQPushButton( this, "b_ok" );
    layout16->addWidget( b_ok );

    KMyFirewallRuleEditorProtocolLayout->addLayout( layout16, 3, 0 );
    languageChange();
    resize( TQSize(527, 458).expandedTo(minimumSizeHint()) );
    clearWState( WState_Polished );

    // signals and slots connections
    connect( b_help, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotHelp() ) );
    connect( b_ok, TQ_SIGNAL( clicked() ), this, TQ_SLOT( accept() ) );
    connect( c_tcp_flags, TQ_SIGNAL( toggled(bool) ), c_inv_flags, TQ_SLOT( setEnabled(bool) ) );
    connect( c_tcp_option, TQ_SIGNAL( toggled(bool) ), sb_tcp_option_num, TQ_SLOT( setEnabled(bool) ) );
    connect( c_tcp_option, TQ_SIGNAL( toggled(bool) ), c_inv_tcp_option, TQ_SLOT( setEnabled(bool) ) );
    connect( c_tcp_flags, TQ_SIGNAL( toggled(bool) ), gb_mask, TQ_SLOT( setEnabled(bool) ) );
    connect( c_tcp_flags, TQ_SIGNAL( toggled(bool) ), gb_comp, TQ_SLOT( setEnabled(bool) ) );
    connect( c_tcp_syn, TQ_SIGNAL( toggled(bool) ), c_inv_syn, TQ_SLOT( setEnabled(bool) ) );
    connect( c_icmp_type, TQ_SIGNAL( toggled(bool) ), cb_icmp_type, TQ_SLOT( setEnabled(bool) ) );
    connect( c_icmp_type, TQ_SIGNAL( toggled(bool) ), c_inv_icmp, TQ_SLOT( setEnabled(bool) ) );
    connect( c_icmp, TQ_SIGNAL( toggled(bool) ), c_icmp_type, TQ_SLOT( setEnabled(bool) ) );
    connect( c_udp, TQ_SIGNAL( toggled(bool) ), tabWidget, TQ_SLOT( setEnabled(bool) ) );
    connect( c_tcp, TQ_SIGNAL( toggled(bool) ), tabWidget, TQ_SLOT( setEnabled(bool) ) );
    connect( c_all, TQ_SIGNAL( toggled(bool) ), c_udp, TQ_SLOT( setDisabled(bool) ) );
    connect( c_all, TQ_SIGNAL( toggled(bool) ), c_icmp, TQ_SLOT( setDisabled(bool) ) );
    connect( c_all, TQ_SIGNAL( toggled(bool) ), c_tcp, TQ_SLOT( setDisabled(bool) ) );
    connect( c_udp, TQ_SIGNAL( toggled(bool) ), c_all, TQ_SLOT( setDisabled(bool) ) );
    connect( c_udp, TQ_SIGNAL( toggled(bool) ), c_tcp, TQ_SLOT( setDisabled(bool) ) );
    connect( c_icmp, TQ_SIGNAL( toggled(bool) ), c_tcp, TQ_SLOT( setDisabled(bool) ) );
    connect( c_icmp, TQ_SIGNAL( toggled(bool) ), c_udp, TQ_SLOT( setDisabled(bool) ) );
    connect( c_icmp, TQ_SIGNAL( toggled(bool) ), c_all, TQ_SLOT( setDisabled(bool) ) );
    connect( c_tcp, TQ_SIGNAL( toggled(bool) ), c_icmp, TQ_SLOT( setDisabled(bool) ) );
    connect( c_tcp, TQ_SIGNAL( toggled(bool) ), c_udp, TQ_SLOT( setDisabled(bool) ) );
    connect( c_tcp, TQ_SIGNAL( toggled(bool) ), c_all, TQ_SLOT( setDisabled(bool) ) );
    connect( c_udp, TQ_SIGNAL( toggled(bool) ), c_icmp, TQ_SLOT( setDisabled(bool) ) );
    connect( c_none_mask, TQ_SIGNAL( toggled(bool) ), c_all_mask, TQ_SLOT( setDisabled(bool) ) );
    connect( c_all_mask, TQ_SIGNAL( toggled(bool) ), c_none_mask, TQ_SLOT( setDisabled(bool) ) );
    connect( c_all_comp, TQ_SIGNAL( toggled(bool) ), c_none_comp, TQ_SLOT( setDisabled(bool) ) );
    connect( c_none_comp, TQ_SIGNAL( toggled(bool) ), c_all_comp, TQ_SLOT( setDisabled(bool) ) );
    connect( c_icmp, TQ_SIGNAL( toggled(bool) ), ButtonGroup1, TQ_SLOT( setEnabled(bool) ) );
    connect( b_ok_2, TQ_SIGNAL( clicked() ), this, TQ_SLOT( reject() ) );
    connect( c_icmp, TQ_SIGNAL( toggled(bool) ), tabWidget, TQ_SLOT( setEnabled(bool) ) );

    // tab order
    setTabOrder( c_all, c_tcp );
    setTabOrder( c_tcp, c_udp );
    setTabOrder( c_udp, c_icmp );
    setTabOrder( c_icmp, c_inv_prot );
    setTabOrder( c_inv_prot, tabWidget );
    setTabOrder( tabWidget, c_tcp_flags );
    setTabOrder( c_tcp_flags, c_tcp_option );
    setTabOrder( c_tcp_option, c_tcp_syn );
    setTabOrder( c_tcp_syn, sb_tcp_option_num );
    setTabOrder( sb_tcp_option_num, c_inv_flags );
    setTabOrder( c_inv_flags, c_inv_tcp_option );
    setTabOrder( c_inv_tcp_option, c_inv_syn );
    setTabOrder( c_inv_syn, c_all_mask );
    setTabOrder( c_all_mask, c_none_mask );
    setTabOrder( c_none_mask, c_syn_mask );
    setTabOrder( c_syn_mask, c_fin_mask );
    setTabOrder( c_fin_mask, c_ack_mask );
    setTabOrder( c_ack_mask, c_rst_mask );
    setTabOrder( c_rst_mask, c_psh_mask );
    setTabOrder( c_psh_mask, c_urg_mask );
    setTabOrder( c_urg_mask, c_all_comp );
    setTabOrder( c_all_comp, c_none_comp );
    setTabOrder( c_none_comp, c_syn_comp );
    setTabOrder( c_syn_comp, c_fin_comp );
    setTabOrder( c_fin_comp, c_ack_comp );
    setTabOrder( c_ack_comp, c_rst_comp );
    setTabOrder( c_rst_comp, c_psh_comp );
    setTabOrder( c_psh_comp, c_urg_comp );
    setTabOrder( c_urg_comp, c_icmp_type );
    setTabOrder( c_icmp_type, cb_icmp_type );
    setTabOrder( cb_icmp_type, c_inv_icmp );
    setTabOrder( c_inv_icmp, b_ok_2 );
    setTabOrder( b_ok_2, b_help );
    setTabOrder( b_help, b_ok );
    setTabOrder( b_ok, c_src_port );
    setTabOrder( c_src_port, c_dest_port );
}

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

/*
 *  Sets the strings of the subwidgets using the current
 *  language.
 */
void KMyFirewallRuleEditorProtocol::languageChange()
{
    setCaption( tr2i18n( "Protocol Options" ) );
    l_greeting->setText( tr2i18n( "Protocol Options" ) );
    gb_protocol->setTitle( tr2i18n( "Match Protocol" ) );
    c_all->setText( tr2i18n( "ALL" ) );
    c_tcp->setText( tr2i18n( "TCP" ) );
    c_inv_prot->setText( tr2i18n( "Invert Protocol Selection" ) );
    c_udp->setText( tr2i18n( "UDP" ) );
    c_icmp->setText( tr2i18n( "ICMP" ) );
    c_dest_port->setText( tr2i18n( "Destination port" ) );
    c_src_port->setText( tr2i18n( "Source port" ) );
    TextLabel2_2->setText( tr2i18n( "<p>Specifie the ports that should match you rule here.<br>\n"
"You may use a portnumber an inclusive portrange or a service name from <i>/etc/sevices</i> to specifie the port." ) );
    tabWidget->changeTab( tab_ports, tr2i18n( "&Ports && Portranges" ) );
    tabWidget->changeTab( tab_multiport, tr2i18n( "&Multiport Extension" ) );
    gb_mask->setTitle( tr2i18n( "Mask" ) );
    c_all_mask->setText( tr2i18n( "ALL" ) );
    c_none_mask->setText( tr2i18n( "NONE" ) );
    c_fin_mask->setText( tr2i18n( "FIN" ) );
    c_urg_mask->setText( tr2i18n( "URG" ) );
    c_psh_mask->setText( tr2i18n( "PSH" ) );
    c_rst_mask->setText( tr2i18n( "RST" ) );
    c_syn_mask->setText( tr2i18n( "SYN" ) );
    c_ack_mask->setText( tr2i18n( "ACK" ) );
    gb_comp->setTitle( tr2i18n( "Comp" ) );
    c_all_comp->setText( tr2i18n( "ALL" ) );
    c_none_comp->setText( tr2i18n( "NONE" ) );
    c_syn_comp->setText( tr2i18n( "SYN" ) );
    c_fin_comp->setText( tr2i18n( "FIN" ) );
    c_ack_comp->setText( tr2i18n( "ACK" ) );
    c_rst_comp->setText( tr2i18n( "RST" ) );
    c_psh_comp->setText( tr2i18n( "PSH" ) );
    c_urg_comp->setText( tr2i18n( "URG" ) );
    TextLabel4->setText( tr2i18n( "<p>Please make sure that you know what you are doing.<br>\n"
"A misuse of this functionality may result in a hard to detect bug in the firewall.</p>\n"
"" ) );
    c_tcp_flags->setText( tr2i18n( "TCP flags" ) );
    c_inv_flags->setText( tr2i18n( "Invert" ) );
    c_tcp_syn->setText( tr2i18n( "NEW connection." ) );
    c_inv_tcp_option->setText( tr2i18n( "Invert" ) );
    c_inv_syn->setText( tr2i18n( "Invert" ) );
    c_tcp_option->setText( tr2i18n( "TCP option no.:" ) );
    tabWidget->changeTab( tab_special_tcp, tr2i18n( "&Special TCP Options" ) );
    ButtonGroup1->setTitle( TQString::null );
    c_inv_icmp->setText( tr2i18n( "Invert ICMP type" ) );
    c_icmp_type->setText( tr2i18n( "Match ICMP type:" ) );
    textLabel1->setText( tr2i18n( "Here you can decide which ICMP Type your rulr should Match." ) );
    tabWidget->changeTab( tab_icmp, tr2i18n( "ICMP" ) );
    b_ok_2->setText( tr2i18n( "&Cancel" ) );
    b_help->setText( tr2i18n( "&Help" ) );
    b_ok->setText( tr2i18n( "&Apply" ) );
}

void KMyFirewallRuleEditorProtocol::slotHelp()
{
    tqWarning( "KMyFirewallRuleEditorProtocol::slotHelp(): Not implemented yet" );
}

void KMyFirewallRuleEditorProtocol::accept()
{
    tqWarning( "KMyFirewallRuleEditorProtocol::accept(): Not implemented yet" );
}

void KMyFirewallRuleEditorProtocol::reject()
{
    tqWarning( "KMyFirewallRuleEditorProtocol::reject(): Not implemented yet" );
}

/****************************************************************************
** KMyFirewallRuleEditorProtocol meta object code from reading C++ file 'kmyfirewallruleeditorprotocol.h'
**
** Created by: The TQt Meta Object Compiler version 26 (TQt 3.5.0)
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#undef TQT_NO_COMPAT
#include "kmyfirewallruleeditorprotocol.h"
#include <ntqmetaobject.h>
#include <ntqapplication.h>

#include <private/qucomextra_p.h>
#if !defined(Q_MOC_OUTPUT_REVISION) || (Q_MOC_OUTPUT_REVISION != 26)
#error "This file was generated using the moc from 3.5.0. It"
#error "cannot be used with the include files from this version of TQt."
#error "(The moc has changed too much.)"
#endif

const char *KMyFirewallRuleEditorProtocol::className() const
{
    return "KMyFirewallRuleEditorProtocol";
}

TQMetaObject *KMyFirewallRuleEditorProtocol::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_KMyFirewallRuleEditorProtocol( "KMyFirewallRuleEditorProtocol", &KMyFirewallRuleEditorProtocol::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString KMyFirewallRuleEditorProtocol::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "KMyFirewallRuleEditorProtocol", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString KMyFirewallRuleEditorProtocol::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "KMyFirewallRuleEditorProtocol", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* KMyFirewallRuleEditorProtocol::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQWidget::staticMetaObject();
    static const TQUMethod slot_0 = {"slotHelp", 0, 0 };
    static const TQUMethod slot_1 = {"accept", 0, 0 };
    static const TQUMethod slot_2 = {"reject", 0, 0 };
    static const TQUMethod slot_3 = {"languageChange", 0, 0 };
    static const TQMetaData slot_tbl[] = {
	{ "slotHelp()", &slot_0, TQMetaData::Public },
	{ "accept()", &slot_1, TQMetaData::Public },
	{ "reject()", &slot_2, TQMetaData::Public },
	{ "languageChange()", &slot_3, TQMetaData::Protected }
    };
    metaObj = TQMetaObject::new_metaobject(
	"KMyFirewallRuleEditorProtocol", parentObject,
	slot_tbl, 4,
	0, 0,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_KMyFirewallRuleEditorProtocol.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* KMyFirewallRuleEditorProtocol::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "KMyFirewallRuleEditorProtocol" ) )
	return this;
    return TQWidget::tqt_cast( clname );
}

bool KMyFirewallRuleEditorProtocol::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: slotHelp(); break;
    case 1: accept(); break;
    case 2: reject(); break;
    case 3: languageChange(); break;
    default:
	return TQWidget::tqt_invoke( _id, _o );
    }
    return true;
}

bool KMyFirewallRuleEditorProtocol::tqt_emit( int _id, TQUObject* _o )
{
    return TQWidget::tqt_emit(_id,_o);
}
#ifndef TQT_NO_PROPERTIES

bool KMyFirewallRuleEditorProtocol::tqt_property( int id, int f, TQVariant* v)
{
    return TQWidget::tqt_property( id, f, v);
}

bool KMyFirewallRuleEditorProtocol::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES
