C++ QListViewItem::isVisible方法代码示例

QListViewItem * ListViewDnd::itemAt( QPoint pos )
{
    QListView * src = (QListView *) this->src;
    int headerHeight = (int)(src->header()->height());
    pos.ry() -= headerHeight;
    QListViewItem * result = src->itemAt( pos );

    if ( result && ( pos.ry() < (src->itemPos(result) + result->height()/2) ) )
	result = result->itemAbove();

    // Wind back if has parent, and we're in flat mode
    while ( result && result->parent() && (dMode & Flat) )
	result = result->parent();

    // Wind back if has parent, and we're in flat mode
    while ( result && !result->isVisible() && result->parent() )
	result = result->parent();

    if ( !result && src->firstChild() && (pos.y() > src->itemRect(src->firstChild()).bottom()) ) {
	result = src->lastItem();
	if ( !result->isVisible() )
	    // Handle special case where last item is actually hidden
	    result = result->itemAbove();
    }

    return result;
}

bool PropertyEditor::handleKeyPress(QKeyEvent* ev) {
    const int k = ev->key();
    const Qt::ButtonState s = ev->state();

    //selection moving
    QListViewItem *item = 0;

    if ((s == NoButton && k == Key_Up) || k == Key_BackTab) {
        //find prev visible
        item = selectedItem() ? selectedItem()->itemAbove() : 0;
        while (item && (!item->isSelectable() || !item->isVisible()))
            item = item->itemAbove();

        if (!item)
            return true;
    } else if (s == NoButton && (k == Key_Down || k == Key_Tab)) {
        //find next visible
        item = selectedItem() ? selectedItem()->itemBelow() : 0;
        while (item && (!item->isSelectable() || !item->isVisible()))
            item = item->itemBelow();

        if (!item)
            return true;
    } else if (s == NoButton && k == Key_Home) {
        if (m_currentEditor && m_currentEditor->hasFocus())
            return false;

        //find 1st visible
        item = firstChild();
        while (item && (!item->isSelectable() || !item->isVisible()))
            item = item->itemBelow();
    } else if (s == NoButton && k == Key_End) {
        if (m_currentEditor && m_currentEditor->hasFocus())
            return false;

        //find last visible
        item = selectedItem();
        QListViewItem *lastVisible = item;
        while (item) { // && (!item->isSelectable() || !item->isVisible()))
            item = item->itemBelow();
            if (item && item->isSelectable() && item->isVisible())
                lastVisible = item;
        }

        item = lastVisible;
    }

    if (item) {
        ev->accept();
        ensureItemVisible(item);
        setSelected(item, true);
        return true;
    }

    return false;
}

void KCookiesManagement::deleteAllCookies()
{
    if(dlg->kListViewSearchLine->text().isEmpty())
    {
        reset();
        m_bDeleteAll = true;
    }
    else
    {
        QListViewItem *item = dlg->lvCookies->firstChild();

        while(item)
        {
            if(item->isVisible())
            {
                deleteCookie(item);
                item = dlg->lvCookies->currentItem();
            }
            else
                item = item->nextSibling();
        }

        const int count = dlg->lvCookies->childCount();
        m_bDeleteAll = (count == 0);
        dlg->pbDeleteAll->setEnabled(count);

        const bool hasSelectedItem = dlg->lvCookies->selectedItem();
        dlg->pbDelete->setEnabled(hasSelectedItem);
        dlg->pbPolicy->setEnabled(hasSelectedItem);
    }

    emit changed(true);
}

void Window::slotReturnPressed() {
	QListViewItem* item = mView->selectedItem();
	if (item && item->isVisible()) {
		switchToWindow(item);
	} else {
		QString cmd = mLineEdit->text();
		run(cmd);
	}
}

	void updateSearch(const QString& text) {
		KListViewSearchLine::updateSearch(text);

		KListView* view = listView();
		QListViewItem* item = view->selectedItem();
		if (item && item->isVisible()) {
			return;
		}

		QListViewItemIterator iterator(view, QListViewItemIterator::Visible);
		item = iterator.current();
		if (item) {
			view->setSelected(item, true);
		}
	}

void popupPublic::sort()
{
        bool reselect=false;
        QListViewItem *current = keysList->firstChild();
        if (current==NULL)
                return;

	if ((untrustedList.find(current->text(2))!=untrustedList.end()) && (!current->text(2).isEmpty())){
                if (current->isSelected()) {
                        current->setSelected(false);
                        reselect=true;
                }
                current->setVisible(false);
		}

        while ( current->nextSibling() ) {
                current = current->nextSibling();
                if ((untrustedList.find(current->text(2))!=untrustedList.end()) && (!current->text(2).isEmpty())) {
                if (current->isSelected()) {
                        current->setSelected(false);
                        reselect=true;
                }
                current->setVisible(false);
		}
        }

	if (reselect || !keysList->currentItem()->isVisible()) {
                QListViewItem *firstvisible;
                firstvisible=keysList->firstChild();
                while (firstvisible->isVisible()!=true) {
                        firstvisible=firstvisible->nextSibling();
                        if (firstvisible==NULL)
                                return;
                }
                keysList->setSelected(firstvisible,true);
		keysList->setCurrentItem(firstvisible);
		keysList->ensureItemVisible(firstvisible);
        }
}

/**
 * Hides all descendant that do not meet the given search criteria.
 * This slot is connected to the search() signal of the QueryResultsMenu
 * object.
 * The search is incremental: only visible items are checked, so that a new
 * search goes over the results of the previous one.
 * @param	pParent	The parent item whose child are searched
 * @param	re		The pattern to search
 * @param	nCol	The list column to search in
 */
void TreeWidget::slotSearch(QListViewItem* pParent, const QRegExp& re, 
	int nCol)
{
	QListViewItem* pItem;
	
	// Get the first child
	if (pParent != NULL)
		pItem = pParent->firstChild();
	else
		pItem = firstChild();
	
	// Iterate over all child items
	while (pItem != NULL) {
		// Filter visible items only
		if (pItem->isVisible() && re.search(pItem->text(nCol)) == -1)
			pItem->setVisible(false);
		
		// Search child items recursively
		slotSearch(pItem, re, nCol);
		
		pItem = pItem->nextSibling();
	}
}