C++ childAt函数代码示例

/**
 * @brief Slot triggers drag-and-drop.
 * The user start draging the pattern he wants to add to the timeline.
 * @param[in] mouse pressed event.
 */
void BARPatternBarScrollAreaContents::mousePressEvent(QMouseEvent *event)
{
    int x=event->pos().x(); /**< retrieves the position of the cursor. */

    BARPatternBar *pBar = static_cast<BARPatternBar*>(childAt(event->pos())); /**< childAt returns a pointer to the child that was clicked. This pointer, of type "widget", is then converted into a BARPatternBar type. */
    if (!pBar){return;} /**< checks that the object created isn't empty (NULL). */

    QSize patternSize(100,60); /**< the following lines created a pixmap that will be displayed on the cursor during drag-and-drop. */
    QPixmap pixmap(patternSize);
    pixmap.fill(pBar->getBgColor());

    QByteArray itemData; /**< the following lines pack up the data to be sent through the drag-and-drop. */
    QDataStream dataStream(&itemData, QIODevice::WriteOnly);
    dataStream << pBar->getBgColor(); /**< stores the color of the bar being dragged. */
    dataStream << pBar->getPatternLength(); /**< stores the duration of the pattern associated to the bar being dragged. */

    QMimeData *mimeData = new QMimeData;
    mimeData->setData("application/x-dnditemdata", itemData); /**< store the data we prepared into the QMimeFile. */
    mimeData->setText(childAt(event->pos())->accessibleName()); /**< store the name of the pattern associated to the bar being dragged. */

    QDrag *drag = new QDrag(this); /**< crates the QDrag object. */
    drag->setMimeData(mimeData); /**< stores the data we packed up into the drag object. */
    drag->setPixmap(pixmap); /**< sets the image to be displayed on the cursor during the drag-and-drop. */

    drag->setHotSpot(event->pos() - pBar->pos()); /**< actually displays the pixmap on the cursor during drag-and-drop. */

    if (drag->exec(Qt::CopyAction | Qt::MoveAction, Qt::CopyAction) == Qt::MoveAction){pBar->close();} /**< lines found on the Internet... */
    else {pBar->show();}
}

long MainWindow::hitTest(const QPoint &pos)
{
    if (IsZoomed(reinterpret_cast<HWND>(winId())))
    {
        auto child = childAt(pos);
        if (!child || child == this)
        {
            return HTCAPTION;
        }
        return HTCLIENT;
    }
    bool left = pos.x() <= 5;
    bool top = pos.y() <= 5;
    bool right = width() - pos.x() <= 5;
    bool bottom = height() - pos.y() <= 5;
    if (left && top)
    {
        return HTTOPLEFT;
    }
    else if (left && bottom)
    {
        return HTBOTTOMLEFT;
    }
    else if (right && top)
    {
        return HTTOPRIGHT;
    }
    else if (right && bottom)
    {
        return HTBOTTOMRIGHT;
    }
    else if (left)
    {
        return HTLEFT;
    }
    else if (top)
    {
        return HTTOP;
    }
    else if (right)
    {
        return HTRIGHT;
    }
    else if (bottom)
    {
        return HTBOTTOM;
    }
    else
    {
        auto child = childAt(pos);
        if (!child || child == this)
        {
            return HTCAPTION;
        }
    }
    return HTCLIENT;
}

QTreeWidgetItem *QgsSettingsTree::createItem( const QString &text,
    QTreeWidgetItem *parent, int index )
{
  QTreeWidgetItem *after = 0;
  if ( index != 0 )
    after = childAt( parent, index - 1 );

  QTreeWidgetItem *item;
  if ( parent )
    item = new QTreeWidgetItem( parent, after );
  else
    item = new QTreeWidgetItem( this, after );

  item->setText( 0, text );
  item->setFlags( item->flags() | Qt::ItemIsEditable );

  QString key = itemKey( item );
  QgsDebugMsg( key );
  if ( settingsMap.contains( key ) )
  {
    QgsDebugMsg( "contains!!!!" );
    QStringList values = settingsMap[ key ];
    item->setText( 3, values.at( 0 ) );
    item->setToolTip( 0, values.at( 1 ) );
    item->setToolTip( 2, values.at( 1 ) );
  }

  // if ( settingsMap.contains(

  return item;
}

/*!
 * Показ меню.
 */
void StatusBar::mouseReleaseEvent(QMouseEvent *event)
{
  if (childAt(event->pos()) == m_icon || event->button() == Qt::RightButton)
    menu(event->globalPos());
  else
    QStatusBar::mouseReleaseEvent(event);
}

	void Moveable::mousePressEvent( MousePressEvent& event )
	{
		int gx, gy;
		Recti rcorner;


		raise();
		event.position( _lx, _ly );
		size( rcorner.x, rcorner.y );
		rcorner.x -= 18;
		rcorner.y -= 18;
		rcorner.setSize( 18, 18 );
		if( rcorner.contains( _lx, _ly  ) && !_togglebutton.state() ) {
			_activeMode = 2;
		} else {
			event.position( gx, gy );
			mapGlobal( gx, gy );
			_activeWidget = childAt( gx, gy );
			if( _activeWidget ) {
				mapGlobal( event.x, event.y );
				_activeWidget->mapLocal( event.x, event.y );
				_activeWidget->mousePressEvent( event );
			} else {
				_activeMode = 1;
			}
		}
	}

/**
 * Get a tile at a mouse position (in pixels).
 * @param pos :: Position of the mouse as returned by QMouseEvent
 * @return :: A pointer to the tile or NULL if clicked on an empty space.
 */
Tile *TiledWindow::getTileAtMousePos(const QPoint &pos) {
  QWidget *w = childAt(pos);
  auto *tile = dynamic_cast<Tile *>(w);
  if (tile)
    return tile;
  return NULL;
}

QWidget * Slider::directChildAt(const QPoint & point)
{
	QWidget * childWidget = childAt(point);
	while (childWidget && (childWidget->parentWidget() != _content))
		childWidget = childWidget->parentWidget();
	return childWidget;
}

		void FunctionGraphicsItem::calculateLayout()
		{
			if(elementLayout() == 0)
				return;

			const ElementLayout & el = *elementLayout();

			QSizeF childrenSize(0,0);
			QSize connectorSize = el.connector().size();

			qreal minLeftPos = 0;

			QList<QString> inputPositions = function()->functionInputPositions();
			foreach(const QString & inputPos, inputPositions)
			{
				ElementGraphicsItem * child = childAt(inputPos);
				if(child == 0)
					continue;

				QSizeF size = child->boundingRect().size();

				// find the inner size of this element
				childrenSize.rwidth() = qMax(childrenSize.width(), size.width());
				childrenSize.rheight() += size.height();
				minLeftPos = qMin(minLeftPos, child->boundingRect().left());
			}

void DragDropArea::mousePressEvent(QMouseEvent *event)
{
    QLabel *child = static_cast<QLabel*>(childAt(event->pos()));
    if (!child)
        return;

    // Only drag children with dynamic property: "drag"
    if (!child->property("drag").toBool())
        return;

    QPoint hotSpot = event->pos() - child->pos();

    QMimeData *mimeData = new QMimeData;
    mimeData->setText(child->text());
    mimeData->setData("application/x-hotspot",
                      QByteArray::number(hotSpot.x())
                      + " " + QByteArray::number(hotSpot.y()));

    QPixmap pixmap(child->size());
    child->render(&pixmap);

    QDrag *drag = new QDrag(this);
    drag->setMimeData(mimeData);
    drag->setPixmap(pixmap);
    drag->setHotSpot(hotSpot);
    drag->exec();
}

/*! \brief handle double click
 *
 * dial or indirect transfer if left mouse button used
 */
void BasePeerWidget::mouseDoubleClickEvent(QMouseEvent *event)
{
    if (event->button() == Qt::LeftButton) {
        QWidget *w = childAt(event->pos());
        QString subwidgetkind;
        if (w) {
            subwidgetkind = w->property("kind").toString();
        }
        // check if we are in communication
        const UserInfo *ui = b_engine->getXivoClientUser();
        if (ui && !ui->phonelist().isEmpty()) {
            foreach (const QString phone, ui->phonelist()) {
                const PhoneInfo *pi = ui->getPhoneInfo(phone);
                const QMap<QString, QVariant> & comms = pi->comms();
                //qDebug() << pi->phoneid() << pi->comms();
                foreach (const QString ts, comms.keys()) {
                    const QMap<QString, QVariant> & comm = comms[ts].toMap();
                    //qDebug() << pi->phoneid() << ts << comm;
                    const QString status = comm["status"].toString();
                    if (status == CHAN_STATUS_LINKED_CALLER || status == CHAN_STATUS_LINKED_CALLED) {
                        QString to;
                        if (m_ui) {
                            to = "user:" + m_ui->userid();
                        } else {
                            to = "ext:" + m_number;
                        }
                        // Initiate an indirect transfer.
                        b_engine->actionCall("atxfer",
                                             "chan:special:me:" + comm["thischannel"].toString(),
                                             to);
                        return;
                    }
                }
            }
        }

void MainWindow::mousePressEvent(QMouseEvent *event)
{
    //1，获取图片
    QLabel *child = static_cast<QLabel*>(childAt(event->pos()));
    if(!child->inherits("QLabel")) return;
    QPixmap pixmap = *child->pixmap();
    //2，自定义MIME类型
    QByteArray itemData;
    QDataStream dataStream(&itemData, QIODevice::WriteOnly);
    dataStream<<pixmap<<QPoint(event->pos()-child->pos());
    //3，将数据放入QMimeData中
    QMimeData *mimeData = new QMimeData;
    mimeData->setData("image/png", itemData);
    //4，将数据放到QDrag中
    QDrag *drag = new QDrag(this);
    drag->setMimeData(mimeData);
    drag->setPixmap(pixmap);
    drag->setHotSpot(event->pos()-child->pos());
    //5，原图添加阴影
    QPixmap tempPixmap = pixmap;
    QPainter painter;
    painter.begin(&tempPixmap);
    painter.fillRect(pixmap.rect(),QColor(127,127,127,127));
    painter.end();
    child->setPixmap(tempPixmap);
    //6，执行拖放操作
    if(drag->exec(Qt::CopyAction|Qt::MoveAction, Qt::CopyAction)
        ==Qt::MoveAction)
        child->close();
    else{
        child->show();
        child->setPixmap(pixmap);
    }
}

void PlayerCardListWidget::mousePressEvent(QMouseEvent *event)
{
    PlayerCardWidget *child = static_cast<PlayerCardWidget*>(childAt(event->pos()));
    if (!child)
        return;
    // Float up the hierachy until the PlayerCardWidget is found, or we hit the current widget
    while ((!child->property("PlayerCardWidget").isValid()) && ((PlayerCardListWidget*)child != this)) {
        child = static_cast<PlayerCardWidget*>(child->parent());
    }
    // If the child is not a PlayerCardWidget, return
    if (!child->property("PlayerCardWidget").isValid())
        return;
    QPoint hotSpot = event->pos() - child->pos();
    QByteArray itemData;
    QDataStream dataStream(&itemData, QIODevice::WriteOnly);
    dataStream << child->playerNumber() << QPoint(hotSpot);

    QMimeData *mimeData = new QMimeData;
    mimeData->setData("application/x-chessplayer", itemData);
    mimeData->setText(child->player()->name());

    QDrag *drag = new QDrag(this);
    drag->setMimeData(mimeData);
    drag->setPixmap(QPixmap::grabWidget(child));
    drag->setHotSpot(hotSpot);

    child->hide();

    if (drag->exec(Qt::MoveAction | Qt::CopyAction, Qt::CopyAction) == Qt::MoveAction)
        child->close();
    else
        child->show();
}

void QTodoList::contextMenuEvent(QContextMenuEvent* event)
{
	QWidget* child_at = childAt(event->pos());
	if(child_at != vbox && child_at != spacer)
		return;

	contextMenu(event->globalPos());
}

int  QAccessibleInterfaceEx_QtDShell::__override_childAt(int  x0, int  y1, bool static_call) const
{
    if (static_call) {
        return 0;
    } else {
        return childAt((int )x0, (int )y1);
    }
}

NPT_List<const Object*> Container::getChildren() const
{
	NPT_List<const Object*> ls;
	for (NPT_Ordinal i = 0; i < childCount(); i++) {
		ls.Add(childAt(i));
	}
	return ls;
}