qcomboview.cpp

/**********************************************************************
**
**
** Implementation of QComboView widget class
**
** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
** Copyright (C) 2003 Alexander Dymo <cloudtemple@mksat.net>
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
**********************************************************************/
 
#include "qcomboview.h"
#ifndef TQT_NO_COMBOBOX
#include "tqpopupmenu.h"
#include "tqlistview.h"
#include "tqpainter.h"
#include "tqdrawutil.h"
#include "tqstrlist.h"
#include "tqpixmap.h"
#include "tqtimer.h"
#include "tqapplication.h"
#include "tqlineedit.h"
#include "tqbitmap.h"
#include "tqeffects_p.h"
#include "tqstringlist.h"
#include "tqcombobox.h"
#include "tqstyle.h"
#include "tqheader.h"
#include <limits.h>
 
class QComboViewData
{
public:
    QComboViewData( QComboView *cb ): current(0), lView( 0 ), combo( cb )
    {
        duplicatesEnabled = true;
        cb->setSizePolicy( TQSizePolicy( TQSizePolicy::Minimum, TQSizePolicy::Fixed ) );
    }
 
    inline TQListView * listView() { return lView; }
    void updateLinedGeometry();
 
    void setListView( TQListView *l ) { lView = l ;
        l->setMouseTracking( true );}
 
    TQListViewItem *current;
    int maxCount;
    int sizeLimit;
    QComboView::Policy p;
    bool autoresize;
    bool poppedUp;
    bool mouseWasInsidePopup;
    bool arrowPressed;
    bool arrowDown;
    bool discardNextMousePress;
    bool shortClick;
    bool useCompletion;
    bool completeNow;
    int completeAt;
    bool duplicatesEnabled;
    int fullHeight, currHeight;
 
    TQLineEdit * ed;  // /bin/ed rules!
    TQTimer *completionTimer;
 
    TQSize sizeHint;
 
private:
    bool    usinglView;
    TQListView   *lView;
    QComboView *combo;
 
};
 
void QComboViewData::updateLinedGeometry()
{
    if ( !ed || !combo )
        return;
    TQRect r = TQStyle::visualRect( combo->style().querySubControlMetrics(TQStyle::CC_ComboBox, combo,
                                        TQStyle::SC_ComboBoxEditField), combo );
 
//    tqWarning("updateLinedGeometry(): currentItem is %d", combo->currentItem() == 0 ? 0 : 1);
    const TQPixmap *pix = combo->currentItem() ? combo->currentItem()->pixmap(0) : 0;
    if ( pix && pix->width() < r.width() )
        r.setLeft( r.left() + pix->width() + 4 );
    if ( r != ed->geometry() )
        ed->setGeometry( r );
}
 
static inline bool checkInsertIndex( const char *method, const char * name,
                     int count, int *index)
{
    bool range_err = (*index > count);
#if defined(TQT_CHECK_RANGE)
    if ( range_err )
    tqWarning( "QComboView::%s: (%s) Index %d out of range",
         method, name ? name : "<no name>", *index );
#else
    Q_UNUSED( method )
    Q_UNUSED( name )
#endif
    if ( *index < 0 )               // append
    *index = count;
    return !range_err;
}
 
 
static inline bool checkIndex( const char *method, const char * name,
                   int count, int index )
{
    bool range_err = (index >= count);
#if defined(TQT_CHECK_RANGE)
    if ( range_err )
    tqWarning( "QComboView::%s: (%s) Index %i out of range",
         method, name ? name : "<no name>", index );
#else
    Q_UNUSED( method )
    Q_UNUSED( name )
#endif
    return !range_err;
}
 

 
 
QComboView::QComboView( bool rw, TQWidget *parent, const char *name )
    : TQWidget( parent, name, WResizeNoErase )
{
    d = new QComboViewData( this );
    setUpListView();
 
    d->current = 0;
    d->maxCount = INT_MAX;
    setSizeLimit(10);
    d->p = AtBottom;
    d->autoresize = false;
    d->poppedUp = false;
    d->arrowDown = false;
    d->discardNextMousePress = false;
    d->shortClick = false;
    d->useCompletion = false;
    d->completeAt = 0;
    d->completeNow = false;
    d->completionTimer = new TQTimer( this );
 
    setFocusPolicy( TQWidget::StrongFocus );
 
    d->ed = 0;
    if ( rw )
    setUpLineEdit();
    setBackgroundMode( PaletteButton, PaletteBase );
}
 
 

 
QComboView::~QComboView()
{
    delete d;
}
 
void QComboView::setDuplicatesEnabled( bool enable )
{
   d->duplicatesEnabled = enable;
}
 
bool QComboView::duplicatesEnabled() const
{
    return d->duplicatesEnabled;
}
 
int QComboView::childCount() const
{
    return d->listView()->childCount();
}
 

 
void QComboView::clear()
{
    d->listView()->resize( 0, 0 );
    d->listView()->clear();
 
    d->current = 0;
    if ( d->ed ) {
        d->ed->setText( TQString::fromLatin1("") );
        d->updateLinedGeometry();
    }
    currentChanged();
}
 
TQListViewItem *QComboView::currentItem() const
{
    return d->current;
}
 
void QComboView::setCurrentItem( TQListViewItem *item )
{
    if ( item == d->current && !d->ed ) {
        return;
    }
 
    if (!item)
    {
        d->current = 0;
        if ( d->ed ) {
//            d->ed->setText( "" );
            d->updateLinedGeometry();
        }
        return;
    }
 
    d->current = item;
    d->completeAt = 0;
    if ( d->ed ) {
        d->ed->setText( item->text(0) );
//        tqWarning("setCurrentItem( %s )", item->text(0).latin1());
        d->updateLinedGeometry();
    }
    if ( d->listView() ) {
        d->listView()->setCurrentItem( item );
    } else {
        internalHighlight( item );
    // internalActivate( item ); ### this leads to weird behavior, as in 3.0.1
    }
 
    currentChanged();
 
    d->listView()->ensureItemVisible(item);
}
 
bool QComboView::autoResize() const
{
    return d->autoresize;
}
 
void QComboView::setAutoResize( bool enable )
{
    if ( (bool)d->autoresize != enable ) {
        d->autoresize = enable;
    if ( enable )
        adjustSize();
    }
}
 

TQSize QComboView::sizeHint() const
{
    if ( isVisible() && d->sizeHint.isValid() )
        return d->sizeHint;
 
    constPolish();
//    int i, w;
    TQFontMetrics fm = fontMetrics();
 
    int maxW = childCount() ? 18 : 7 * fm.width(TQChar('x')) + 18;
    int maxH = TQMAX( fm.lineSpacing(), 14 ) + 2;
 
/*    for( i = 0; i < count(); i++ ) {
        w = d->listView()->item( i )->width( d->listView() );
        if ( w > maxW )
            maxW = w;
    }
*/
    d->sizeHint = (style().sizeFromContents(TQStyle::CT_ComboBox, this,
        TQSize(maxW, maxH)).expandedTo(TQApplication::globalStrut()));
 
    return d->sizeHint;
}
 

 
void QComboView::internalActivate( TQListViewItem * item )
{
    if (!item)
    {
        d->current = 0;
        if ( d->ed ) {
//            d->ed->setText( "" );
            d->updateLinedGeometry();
        }
        return;
    }
    popDownListView();
    d->poppedUp = false;
 
    d->current = item;
 
    TQString t( item->text(0) );
    if ( d->ed ) {
        d->ed->setText( t );
//        tqWarning("internalActivate( %s )", item->text(0).latin1());
        d->updateLinedGeometry();
    }
    emit activated( item );
    emit activated( t );
 
//    item->setOpen(true);
}

 
void QComboView::internalHighlight( TQListViewItem * item )
{
    if (!item)
    {
        d->current = 0;
        if ( d->ed ) {
//            d->ed->setText( "" );
            d->updateLinedGeometry();
        }
        return;
    }
    emit highlighted( item );
    TQString t = item->text(0);
    if ( !t.isNull() )
        emit highlighted( t );
}

void QComboView::internalClickTimeout()
{
    d->shortClick = false;
}

 
void QComboView::setPalette( const TQPalette &palette )
{
    TQWidget::setPalette( palette );
    if( d ) {
        if(d->listView())
            d->listView()->setPalette( palette );
    }
}

 
void QComboView::setFont( const TQFont &font )
{
    d->sizeHint = TQSize();      // invalidate size hint
    TQWidget::setFont( font );
    d->listView()->setFont( font );
    if (d->ed)
        d->ed->setFont( font );
    if ( d->autoresize )
        adjustSize();
}
 

 
void QComboView::resizeEvent( TQResizeEvent * e )
{
    if ( d->ed )
        d->updateLinedGeometry();
    d->listView()->resize( width(), d->listView()->height() );
    TQWidget::resizeEvent( e );
}

 
void QComboView::paintEvent( TQPaintEvent * )
{
    TQPainter p( this );
    const TQColorGroup & g = colorGroup();
    p.setPen(g.text());
 
    TQStyle::SFlags flags = TQStyle::Style_Default;
    if (isEnabled())
        flags |= TQStyle::Style_Enabled;
    if (hasFocus())
        flags |= TQStyle::Style_HasFocus;
 
    if ( width() < 5 || height() < 5 ) {
        qDrawShadePanel( &p, rect(), g, false, 2,
                &g.brush( TQColorGroup::Button ) );
        return;
    }
 
//    bool reverse = TQApplication::reverseLayout();
    style().drawComplexControl( TQStyle::CC_ComboBox, &p, this, rect(), g,
                    flags, TQStyle::SC_All,
                    (d->arrowDown ?
                    TQStyle::SC_ComboBoxArrow :
                    TQStyle::SC_None ));
 
    TQRect re = style().querySubControlMetrics( TQStyle::CC_ComboBox, this,
                        TQStyle::SC_ComboBoxEditField );
    re = TQStyle::visualRect(re, this);
    p.setClipRect( re );
 
    if ( !d->ed ) {
        TQListViewItem * item = d->current;
        if ( item ) {
            // we calculate the TQListBoxTexts height (ignoring strut)
            int itemh = d->listView()->fontMetrics().lineSpacing() + 2;
            p.translate( re.x(), re.y() + (re.height() - itemh)/2  );
            item->paintCell( &p, d->listView()->colorGroup(), 0, width(), AlignLeft | AlignVCenter );
        }
    } else if ( d->listView() && d->listView()->currentItem( ) && d->current ) {
        TQListViewItem * item = d->current ;
        const TQPixmap *pix = item->pixmap(0);
        if ( pix ) {
            p.fillRect( re.x(), re.y(), pix->width() + 4, re.height(),
                    colorGroup().brush( TQColorGroup::Base ) );
            p.drawPixmap( re.x() + 2, re.y() +
                    ( re.height() - pix->height() ) / 2, *pix );
        }
    }
    p.setClipping( false );
}
 

 
void QComboView::mousePressEvent( TQMouseEvent *e )
{
    if ( e->button() != TQt::LeftButton )
        return;
    if ( d->discardNextMousePress ) {
        d->discardNextMousePress = false;
        return;
    }
    TQRect arrowRect = style().querySubControlMetrics( TQStyle::CC_ComboBox, this,
                                TQStyle::SC_ComboBoxArrow);
    arrowRect = TQStyle::visualRect(arrowRect, this);
 
    // Correction for motif style, where arrow is smaller
    // and thus has a rect that doesn't fit the button.
    arrowRect.setHeight( TQMAX(  height() - (2 * arrowRect.y()), arrowRect.height() ) );
 
    if ( childCount() && ( !editable() || arrowRect.contains( e->pos() ) ) ) {
        d->arrowPressed = false;
        listView()->blockSignals( true );
        tqApp->sendEvent( listView(), e ); // trigger the listbox's autoscroll
        listView()->blockSignals( false );
        popup();
        if ( arrowRect.contains( e->pos() ) ) {
            d->arrowPressed = true;
            d->arrowDown    = true;
            repaint( false );
        }
        TQTimer::singleShot( 200, this, TQ_SLOT(internalClickTimeout()));
        d->shortClick = true;
    }
}

 
void QComboView::mouseMoveEvent( TQMouseEvent * )
{
}

 
void QComboView::mouseReleaseEvent( TQMouseEvent * )
{
}

 
void QComboView::mouseDoubleClickEvent( TQMouseEvent *e )
{
    mousePressEvent( e );
}
 

 
void QComboView::keyPressEvent( TQKeyEvent *e )
{
    TQListViewItem *c = currentItem();
    if ( ( e->key() == Key_F4 && e->state() == 0 ) ||
        ( e->key() == Key_Down && (e->state() & AltButton) ) ||
        ( !d->ed && e->key() == Key_Space ) ) {
        if ( childCount() ) {
            popup();
        }
        return;
    } else if ( e->key() == Key_Up ) {
/*        if ((!c) && (listView()->firstChild()))
            setCurrentItem(listView()->firstChild());*/
        if (c && c->itemAbove() )
            setCurrentItem( c->itemAbove() );
        else
            return;
    } else if ( e->key() == Key_Down ) {
        if ((!c) && (listView()->firstChild()))
        {
            setCurrentItem(listView()->firstChild());
            return;
        }
        if ( c && c->itemBelow() )
            setCurrentItem( c->itemBelow() );
        else
            return;
    } else if ( e->key() == Key_Home && ( !d->ed || !d->ed->hasFocus() ) ) {
        if (listView()->firstChild())
            setCurrentItem( listView()->firstChild() );
        else
            return;
    } else if ( e->key() == Key_End && ( !d->ed || !d->ed->hasFocus() ) ) {
        if (listView()->lastItem())
            setCurrentItem( listView()->lastItem() );
        else
            return;
    } else if ( !d->ed && e->ascii() >= 32 && !e->text().isEmpty() ) {
        if ( !d->completionTimer->isActive() ) {
            d->completeAt = 0;
            c = completionIndex( e->text(), c->itemBelow() );
            if ( c ) {
                setCurrentItem( c );
                d->completeAt = e->text().length();
            }
            else
                return;
        } else {
            d->completionTimer->stop();
            TQString ct = currentText().left( d->completeAt ) + e->text();
            c = completionIndex( ct, c );
            if ( c == 0 && d->completeAt > 0 ) {
                c = completionIndex( e->text(), listView()->firstChild() );
                ct = e->text();
            }
            d->completeAt = 0;
            if ( c ) {
                setCurrentItem( c );
                d->completeAt = ct.length();
            }
            else
                return;
        }
        d->completionTimer->start( 400, true );
    } else {
        e->ignore();
        return;
    }
 
    c = currentItem();
    if ( childCount() && c && !c->text(0).isNull() )
        emit activated( c->text(0) );
    emit activated( c );
}
 
TQString QComboView::currentText() const
{
    if ( d->ed )
        return d->ed->text();
    else if ( d->current )
        return currentItem()->text(0);
    else
        return TQString();
}

 
void QComboView::focusInEvent( TQFocusEvent * e )
{
    TQWidget::focusInEvent( e );
    d->completeNow = false;
    d->completeAt = 0;
 
    emit focusGranted();
}

 
void QComboView::focusOutEvent( TQFocusEvent * e )
{
    TQWidget::focusOutEvent( e );
    d->completeNow = false;
    d->completeAt = 0;
 
    emit focusLost();
}

 
void QComboView::wheelEvent( TQWheelEvent *e )
{
    if ( d->poppedUp ) {
        TQApplication::sendEvent( d->listView(), e );
    } else {
        if ( e->delta() > 0 ) {
            TQListViewItem *c = currentItem();
            if ( c && c->itemAbove() ) {
                setCurrentItem( c->itemAbove() );
                emit activated( currentItem() );
                emit activated( currentText() );
            }
        } else {
            TQListViewItem *c = currentItem();
            if ( c && c->itemBelow() ) {
                setCurrentItem( c->itemBelow() );
                emit activated( currentItem() );
                emit activated( currentText() );
            }
        }
        e->accept();
    }
}
 
int childCount(TQListViewItem *it)
{
    int count = 1;
    TQListViewItem * myChild = it->firstChild();
    while( myChild ) {
        count += childCount(myChild);
        myChild = myChild->nextSibling();
    }
    return count;
}
 
int childCount(TQListView *lv)
{
    int count = 0;
    TQListViewItem * myChild = lv->firstChild();
    while( myChild ) {
        count += childCount(myChild);
//        count += 1;
        myChild = myChild->nextSibling();
    }
    return count;
}

static int listHeight( TQListView *l, int /*sl*/ )
{
/*    if ( l->childCount() > 0 )
        return TQMIN( l->childCount(), (uint)sl) * l->firstChild()->height();
    else*/
 
    int prefH = 0;
    int ch = childCount(l);
    ch = TQMIN(ch, 10);
    if (l->firstChild())
    {
        prefH = ch * l->firstChild()->height();
    }
    else
        prefH = l->sizeHint().height();
 
    if (l->header()->isVisible())
        prefH += l->header()->sizeHint().height();
 
//    return prefH < l->sizeHint().height() ? prefH : l->sizeHint().height();
 
    return prefH+2;
}

 
void QComboView::popup()
{
    if ( !childCount() )
        return;
 
    // Send all listbox events to eventFilter():
    TQListView* lb = d->listView();
    lb->triggerUpdate( );
    lb->installEventFilter( this );
    lb->viewport()->installEventFilter( this );
    d->mouseWasInsidePopup = false;
//    int w = lb->variableWidth() ? lb->sizeHint().width() : width();
    int w = width();
    int h = listHeight( lb, d->sizeLimit );
    TQRect screen = TQApplication::desktop()->availableGeometry( const_cast<QComboView*>(this) );
 
    int sx = screen.x();        // screen pos
    int sy = screen.y();
    int sw = screen.width();    // screen width
    int sh = screen.height();   // screen height
    TQPoint pos = mapToGlobal( TQPoint(0,height()) );
    // ## Similar code is in TQPopupMenu
    int x = pos.x();
    int y = pos.y();
 
    // the complete widget must be visible
    if ( x + w > sx + sw )
        x = sx+sw - w;
    if ( x < sx )
        x = sx;
    if (y + h > sy+sh && y - h - height() >= 0 )
        y = y - h - height();
    TQRect rect =
    style().querySubControlMetrics( TQStyle::CC_ComboBox, this,
                    TQStyle::SC_ComboBoxListBoxPopup,
                    TQStyleOption( x, y, w, h ) );
    if ( rect.isNull() )
        rect.setRect( x, y, w, h );
    lb->setGeometry( rect );
 
    lb->raise();
    bool block = lb->signalsBlocked();
    lb->blockSignals( true );
    TQListViewItem *currentLBItem = d->current ;
    lb->setCurrentItem( currentLBItem );
    // set the current item to also be the selected item if it isn't already
    if ( currentLBItem && currentLBItem->isSelectable() && !currentLBItem->isSelected() )
        lb->setSelected( currentLBItem, true );
    lb->blockSignals( block );
    lb->setVScrollBarMode(TQScrollView::Auto);
 
//#ifndef TQT_NO_EFFECTS
/*    if ( TQApplication::isEffectEnabled( UI_AnimateCombo ) ) {
        if ( lb->y() < mapToGlobal(TQPoint(0,0)).y() )
        qScrollEffect( lb, TQEffects::UpScroll );
        else
        qScrollEffect( lb );
    } else*/
//#endif
        lb->show();
    d->poppedUp = true;
}
 

void QComboView::updateMask()
{
    TQBitmap bm( size() );
    bm.fill( color0 );
 
    {
        TQPainter p( &bm, this );
        style().drawComplexControlMask(TQStyle::CC_ComboBox, &p, this, rect());
    }
 
    setMask( bm );
}

void QComboView::popDownListView()
{
    d->listView()->removeEventFilter( this );
    d->listView()->viewport()->removeEventFilter( this );
    d->listView()->hide();
    d->listView()->setCurrentItem( d->current );
    if ( d->arrowDown ) {
        d->arrowDown = false;
        repaint( false );
    }
    d->poppedUp = false;
}
 

 
void QComboView::reIndex()
{
}

 
void QComboView::currentChanged()
{
    if ( d->autoresize )
        adjustSize();
    update();
}

 
bool QComboView::eventFilter( TQObject *object, TQEvent *event )
{
    if ( !event )
        return true;
    else if ( object == d->ed ) {
        if ( event->type() == TQEvent::KeyPress ) {
            bool isAccepted = ( (TQKeyEvent*)event )->isAccepted();
            keyPressEvent( (TQKeyEvent *)event );
            if ( ((TQKeyEvent *)event)->isAccepted() ) {
                d->completeNow = false;
                return true;
            } else if ( ((TQKeyEvent *)event)->key() != Key_End ) {
                d->completeNow = true;
                d->completeAt = d->ed->cursorPosition();
            }
            if ( isAccepted )
                ( (TQKeyEvent*)event )->accept();
            else
                ( (TQKeyEvent*)event )->ignore();
        } else if ( event->type() == TQEvent::KeyRelease ) {
            d->completeNow = false;
            keyReleaseEvent( (TQKeyEvent *)event );
            return ((TQKeyEvent *)event)->isAccepted();
        } else if ( event->type() == TQEvent::FocusIn ) {
            focusInEvent( (TQFocusEvent *)event );
        } else if ( event->type() == TQEvent::FocusOut ) {
            focusOutEvent( (TQFocusEvent *)event );
        } else if ( d->useCompletion && d->completeNow ) {
            if ( !d->ed->text().isNull() &&
            d->ed->cursorPosition() > d->completeAt &&
            d->ed->cursorPosition() == (int)d->ed->text().length() ) {
                d->completeNow = false;
                TQString ct( d->ed->text() );
                TQListViewItem *i = completionIndex( ct, currentItem() );
                if ( i ) {
                    TQString it = i->text(0);
                    d->ed->validateAndSet( it, ct.length(),
                            ct.length(), it.length() );
                }
            }
        }
    } else if ( ( object == d->listView() ||
                        object == d->listView()->viewport() )) {
        TQMouseEvent *e = (TQMouseEvent*)event;
        switch( event->type() ) {
        case TQEvent::MouseMove:
            if ( !d->mouseWasInsidePopup  ) {
//                tqWarning("!d->mouseWasInsidePopup");
                TQPoint pos = e->pos();
                if ( d->listView()->rect().contains( pos ) )
                    d->mouseWasInsidePopup = true;
                // Check if arrow button should toggle
                if ( d->arrowPressed ) {
                    TQPoint comboPos;
                    comboPos = mapFromGlobal( d->listView()->mapToGlobal(pos) );
                    TQRect arrowRect =
                    style().querySubControlMetrics( TQStyle::CC_ComboBox, this,
                                    TQStyle::SC_ComboBoxArrow);
                    arrowRect = TQStyle::visualRect(arrowRect, this);
                    if ( arrowRect.contains( comboPos ) ) {
                        if ( !d->arrowDown  ) {
                            d->arrowDown = true;
                            repaint( false );
                        }
                        } else {
                        if ( d->arrowDown  ) {
                            d->arrowDown = false;
                            repaint( false );
                        }
                    }
                }
            } else if ((e->state() & ( TQt::RightButton | TQt::LeftButton | TQt::MidButton ) ) == 0 &&
                style().styleHint(TQStyle::SH_ComboBox_ListMouseTracking, this)) {
//                tqWarning("event filter:: emu");
                TQWidget *mouseW = TQApplication::widgetAt( e->globalPos(), true );
//                if ( mouseW == d->listView()->viewport() ) { //###
                if ( mouseW == d->listView()->viewport() ) {
                    TQListViewItem *sel = d->listView()->itemAt(e->pos());
                    if (sel)
                    {
                        d->listView()->setCurrentItem(sel);
                        d->listView()->setSelected(sel, true);
                    }
                    return true;
                }
            }
 
            break;
        case TQEvent::MouseButtonRelease:
            if ( d->listView()->rect().contains( e->pos() ) ) {
                TQMouseEvent tmp( TQEvent::MouseButtonDblClick,
                        e->pos(), e->button(), e->state() ) ;
                // will hide popup
                TQApplication::sendEvent( object, &tmp );
                return true;
            } else {
                if ( d->mouseWasInsidePopup ) {
                    popDownListView();
                } else {
                    d->arrowPressed = false;
                    if ( d->arrowDown  ) {
                        d->arrowDown = false;
                        repaint( false );
                    }
                }
            }
            break;
        case TQEvent::MouseButtonDblClick:
        case TQEvent::MouseButtonPress:
            if ( !d->listView()->rect().contains( e->pos() ) ) {
                TQPoint globalPos = d->listView()->mapToGlobal(e->pos());
                if ( TQApplication::widgetAt( globalPos, true ) == this ) {
                    d->discardNextMousePress = true;
                    // avoid popping up again
                }
                popDownListView();
                return true;
            }
            break;
        case TQEvent::KeyPress:
            switch( ((TQKeyEvent *)event)->key() ) {
                case Key_Up:
                case Key_Down:
                    if ( !(((TQKeyEvent *)event)->state() & AltButton) )
                        break;
                case Key_F4:
                case Key_Escape:
                    if ( d->poppedUp ) {
                        popDownListView();
                        return true;
                    }
                break;
                case Key_Enter:
                case Key_Return:
                    // work around TQDialog's enter handling
                    return false;
                default:
                break;
            }
            break;
        case TQEvent::Hide:
            popDownListView();
            break;
        default:
            break;
        }
    }
    return TQWidget::eventFilter( object, event );
}
 

 
TQListViewItem *QComboView::completionIndex( const TQString & prefix,
                    TQListViewItem *startingAt ) const
{
    TQListViewItem *start = startingAt;
/*    if ( start < 0 || start >= count() )
        start = 0;
    if ( start >= count() )
        return -1;*/
    if (!start)
        start = listView()->firstChild();
    if (!start)
        return 0;
/*    if (!start->itemBelow())
        return 0;*/
    TQString match = prefix.lower();
    if ( match.length() < 1 )
        return start;
 
    TQString current;
    TQListViewItem *i = start;
    do {
        current = i->text(0).lower();
        if ( current.startsWith( match ) )
            return i;
        i = i->itemBelow();
        if ( i )
            i = listView()->firstChild();
    } while ( i != start );
    return 0;
}
 
 
int QComboView::sizeLimit() const
{
    return d ? d->sizeLimit : INT_MAX;
}
 
void QComboView::setSizeLimit( int lines )
{
    d->sizeLimit = lines;
}
 
 
/*int QComboView::maxCount() const
{
    return d ? d->maxCount : INT_MAX;
}
 
void QComboView::setMaxCount( int count )
{
    int l = this->count();
    while( --l > count )
        removeItem( l );
    d->maxCount = count;
}
*/
QComboView::Policy QComboView::insertionPolicy() const
{
    return d->p;
}
 
void QComboView::setInsertionPolicy( Policy policy )
{
    d->p = policy;
}
 
 

 
void QComboView::returnPressed()
{
    TQString s( d->ed->text() );
 
    if ( s.isEmpty() )
        return;
 
    TQListViewItem *c = 0;
    bool doInsert = true;
    if ( !d->duplicatesEnabled ) {
        c = listView()->findItem(s, 0);
        if ( c )
            doInsert = false;
    }
 
    if ( doInsert ) {
        if ( insertionPolicy() != NoInsertion ) {
/*            int cnt = count();
            while ( cnt >= d->maxCount ) {
                removeItem( --cnt );
            }*/
        }
 
        switch ( insertionPolicy() ) {
            case AtCurrent:
                if ( s != currentItem()->text(0) )
                    currentItem()->setText(0, s);
                emit activated( currentItem() );
                emit activated( s );
                return;
            case NoInsertion:
                emit activated( s );
                return;
            case AtTop:
                c = 0;
                return;
//                break;
            case AtBottom:
                c = new TQListViewItem(listView(), listView()->lastItem(), s);
                break;
            case BeforeCurrent:
                if (currentItem() && currentItem()->itemAbove())
                    c = new TQListViewItem(listView(), currentItem()->itemAbove(), s);
                else
                {
                    c = 0;
                    return;
                }
                break;
            case AfterCurrent:
                if (currentItem() && currentItem()->itemBelow())
                    c = new TQListViewItem(listView(), currentItem()->itemBelow(), s);
                else
                {
                    c = 0;
                    return;
                }
                break;
        }
    }
 
    if (c)
    {
        setCurrentItem( c );
        emit activated( c );
        emit activated( s );
    }
}
 

 
void QComboView::setEnabled( bool enable )
{
    TQWidget::setEnabled( enable );
}
 
 

 
void QComboView::setValidator( const TQValidator * v )
{
    if ( d && d->ed )
        d->ed->setValidator( v );
}
 

 
const TQValidator * QComboView::validator() const
{
    return d && d->ed ? d->ed->validator() : 0;
}
 

 
void QComboView::clearValidator()
{
    if ( d && d->ed )
        d->ed->setValidator( 0 );
}
 

 
void QComboView::setListView( TQListView * newListView )
{
    clear();
 
    delete d->listView();
 
    newListView->reparent( this, WType_Popup, TQPoint(0,0), false );
    d->setListView( newListView );
    d->listView()->setFont( font() );
    d->listView()->setPalette( palette() );
/*    d->listView()->setVScrollBarMode(TQScrollView::AlwaysOff);
    d->listView()->setHScrollBarMode(TQScrollView::AlwaysOff);*/
    d->listView()->setFrameStyle( TQFrame::Box | TQFrame::Plain );
    d->listView()->setLineWidth( 1 );
/*    d->listView()->setRootIsDecorated( true );
    d->listView()->setAllColumnsShowFocus(true);*/
    d->listView()->resize( 100, 10 );
 
    if (d->listView()->firstChild())
        d->current = d->listView()->firstChild();
 
//    d->listView()->header()->hide();
 
 
/*    d->listView()->setFont( font() );
    d->listView()->setPalette( palette() );
    d->listView()->setVScrollBarMode( TQScrollView::AlwaysOff );
    d->listView()->setHScrollBarMode( TQScrollView::AlwaysOff );
    d->listView()->setFrameStyle( TQFrame::Box | TQFrame::Plain );
    d->listView()->setLineWidth( 1 );
    d->listView()->setRootIsDecorated( true );
    d->listView()->setAllColumnsShowFocus(true);
    d->listView()->addColumn("");
    d->listView()->resize( 100, 10 );
*/
 
    connect( d->listView(), TQ_SIGNAL(returnPressed(TQListViewItem*)),
            TQ_SLOT(internalActivate(TQListViewItem*)));
    connect( d->listView(), TQ_SIGNAL(doubleClicked(TQListViewItem*)),
            TQ_SLOT(internalActivate(TQListViewItem*)));
    connect( d->listView(), TQ_SIGNAL(doubleClicked(TQListViewItem*)),
            TQ_SLOT(checkState(TQListViewItem*)));
    connect( d->listView(), TQ_SIGNAL(currentChanged(TQListViewItem*)),
            TQ_SLOT(internalHighlight(TQListViewItem*)));
    connect( d->listView(), TQ_SIGNAL(selectionChanged(TQListViewItem*)),
            TQ_SLOT(internalHighlight(TQListViewItem*)));
}
 

 
TQListView * QComboView::listView() const
{
    return d ? d->listView() : 0;
}

TQLineEdit* QComboView::lineEdit() const
{
    return d->ed;
}
 
 

 
void QComboView::clearEdit()
{
    if ( d && d->ed )
        d->ed->clear();
}
 

 
void QComboView::setEditText( const TQString &newText )
{
    if ( d && d->ed ) {
        d->updateLinedGeometry();
        d->ed->setText( newText );
    }
}
 
void QComboView::setAutoCompletion( bool enable )
{
    d->useCompletion = enable;
    d->completeNow = false;
}
 
 
bool QComboView::autoCompletion() const
{
    return d->useCompletion;
}

void QComboView::styleChange( TQStyle& s )
{
    d->sizeHint = TQSize();     // invalidate size hint...
    if ( d->ed )
        d->updateLinedGeometry();
    TQWidget::styleChange( s );
}
 
bool QComboView::editable() const
{
    return d->ed != 0;
}
 
void QComboView::setEditable( bool y )
{
    if ( y == editable() )
        return;
    if ( y ) {
        setUpListView();
        setUpLineEdit();
        d->ed->show();
        if ( currentItem() )
            setEditText( currentText() );
        } else {
            delete d->ed;
        d->ed = 0;
    }
 
    setFocusPolicy( TQWidget::StrongFocus );
    updateGeometry();
    update();
}
 
 
void QComboView::setUpListView()
{
    d->setListView( new TQListView( this, "in-combo", WType_Popup ) );
 
    d->listView()->setFont( font() );
    d->listView()->setPalette( palette() );
/*    d->listView()->setVScrollBarMode( TQScrollView::AlwaysOff );
    d->listView()->setHScrollBarMode( TQScrollView::AlwaysOff );*/
    d->listView()->setFrameStyle( TQFrame::Box | TQFrame::Plain );
    d->listView()->setLineWidth( 1 );
    d->listView()->setRootIsDecorated( false );
    d->listView()->setAllColumnsShowFocus(true);
    d->listView()->addColumn("");
    d->listView()->resize( 100, 10 );
    d->listView()->setResizeMode(TQListView::LastColumn);
 
    if (d->listView()->firstChild())
        d->current = d->listView()->firstChild();
 
    d->listView()->header()->hide();
 
    connect( d->listView(), TQ_SIGNAL(returnPressed(TQListViewItem*)),
            TQ_SLOT(internalActivate(TQListViewItem*)));
    connect( d->listView(), TQ_SIGNAL(doubleClicked(TQListViewItem*)),
            TQ_SLOT(internalActivate(TQListViewItem*)));
    connect( d->listView(), TQ_SIGNAL(doubleClicked(TQListViewItem*)),
            TQ_SLOT(checkState(TQListViewItem*)));
    connect( d->listView(), TQ_SIGNAL(currentChanged(TQListViewItem*)),
            TQ_SLOT(internalHighlight(TQListViewItem*)));
    connect( d->listView(), TQ_SIGNAL(selectionChanged(TQListViewItem*)),
            TQ_SLOT(internalHighlight(TQListViewItem*)));
}
 
 
void QComboView::setUpLineEdit()
{
    if ( !d->ed )
        setLineEdit( new TQLineEdit( this, "combo edit" ) );
}

 
void QComboView::setLineEdit( TQLineEdit *edit )
{
    if ( !edit ) {
#if defined(TQT_CHECK_NULL)
        Q_ASSERT( edit != 0 );
#endif
        return;
    }
 
    edit->setText( currentText() );
    if ( d->ed ) {
        int start = 0, end = 0;
        d->ed->getSelection( &start, &end );
        edit->setSelection( start, end );
        edit->setCursorPosition( d->ed->cursorPosition() );
        edit->setEdited( d->ed->edited() );
        delete d->ed;
    }
 
    d->ed = edit;
 
    if ( edit->parent() != this ) {
        edit->reparent( this, TQPoint(0,0), false );
        edit->setFont( font() );
    }
 
    connect (edit, TQ_SIGNAL( textChanged( const TQString& ) ),
            this, TQ_SIGNAL( textChanged( const TQString& ) ) );
    connect( edit, TQ_SIGNAL(returnPressed()), TQ_SLOT(returnPressed()) );
 
    edit->setFrame( false );
    d->updateLinedGeometry();
    edit->installEventFilter( this );
    setFocusProxy( edit );
    setFocusPolicy( TQWidget::StrongFocus );
 
    setUpListView();
 
    if ( isVisible() )
        edit->show();
 
    updateGeometry();
    update();
}
 
void QComboView::setCurrentText( const TQString& txt )
{
    TQListViewItem *i;
    i = listView()->findItem(txt, 0);
    if ( i )
        setCurrentItem( i );
    else if ( d->ed )
        d->ed->setText( txt );
    else if (currentItem())
        currentItem()->setText(0, txt);
}
 
void QComboView::checkState( TQListViewItem * item)
{
    item->setOpen(!item->isOpen());
}
 
void QComboView::setCurrentActiveItem( TQListViewItem * item )
{
    if ( item == d->current && !d->ed ) {
        return;
    }
 
    d->current = item;
    d->completeAt = 0;
    if ( d->ed ) {
        d->ed->setText( item->text(0) );
    d->ed->setCursorPosition(0);
//        tqWarning("setCurrentActiveItem( %s )", item->text(0).latin1());
        d->updateLinedGeometry();
    }
    if ( d->listView() ) {
        d->listView()->setCurrentItem( item );
        emit activated( item );
        emit activated( item->text(0) );
    } else {
        internalHighlight( item );
        internalActivate( item );
    }
 
    currentChanged();
 
    d->listView()->ensureItemVisible(item);
}
 
#include "qcomboview.moc"
 
#endif // TQT_NO_COMBOBOX