// Eventfilter: Only needed under Windows. // Without this, files dropped in the line edit have URL-encoding. // This eventfilter decodes the filenames as needed by KDiff3. bool OpenDialog::eventFilter(QObject* o, QEvent* e) { if ( e->type()==QEvent::DragEnter ) { QDragEnterEvent* d = static_cast<QDragEnterEvent*>(e); d->setAccepted( d->mimeData()->hasUrls() ); return true; } if (e->type()==QEvent::Drop) { QDropEvent* d = static_cast<QDropEvent*>(e); if ( !d->mimeData()->hasUrls() ) return false; QList<QUrl> lst = d->mimeData()->urls(); if ( lst.count() > 0 ) { static_cast<QLineEdit*>(o)->setText( QDir::toNativeSeparators( lst[0].toLocalFile() ) ); static_cast<QLineEdit*>(o)->setFocus(); } return true; } return false; }
bool RegisterP12::eventFilter( QObject *o, QEvent *e ) { if( o == d->p12Cert && e->type() == QEvent::Drop ) { QDropEvent *drop = static_cast<QDropEvent*>(e); if( drop->mimeData()->hasUrls() ) { d->p12Cert->setText( drop->mimeData()->urls().value( 0 ).toLocalFile() ); return true; } } return QWidget::eventFilter( o, e ); }
bool SettingsDialog::eventFilter( QObject *o, QEvent *e ) { if( o == d->p12Cert && e->type() == QEvent::Drop ) { QDropEvent *d = static_cast<QDropEvent*>(e); if( d->mimeData()->hasUrls() ) { setP12Cert( d->mimeData()->urls().value( 0 ).toLocalFile() ); return true; } } return QWidget::eventFilter( o, e ); }
bool DockedMdiArea::event(QEvent *event) { // Listen for desktop file manager drop and emit a signal once a file is // dropped. switch (event->type()) { case QEvent::DragEnter: { QDragEnterEvent *e = static_cast<QDragEnterEvent*>(event); if (!uiFiles(e->mimeData()).empty()) { e->acceptProposedAction(); return true; } } break; case QEvent::Drop: { QDropEvent *e = static_cast<QDropEvent*>(event); const QStringList files = uiFiles(e->mimeData()); const QStringList::const_iterator cend = files.constEnd(); for (QStringList::const_iterator it = files.constBegin(); it != cend; ++it) { emit fileDropped(*it); } e->acceptProposedAction(); return true; } break; default: break; } return QMdiArea::event(event); }
/** Redefined to forward events to children. */ bool TabPlaylist::eventFilter(QObject *obj, QEvent *event) { if (event->type() == QEvent::DragEnter) { event->accept(); return true; } else if (event->type() == QEvent::Drop) { QDropEvent *de = static_cast<QDropEvent*>(event); if (de->source() == NULL) { // Drag & Drop comes from another application but has landed in the playlist area de->ignore(); QDropEvent *d = new QDropEvent(de->pos(), de->possibleActions(), de->mimeData(), de->mouseButtons(), de->keyboardModifiers()); _mainWindow->dispatchDrop(d); return true; } else { if (obj == cornerWidget()) { auto p = this->addPlaylist(); p->forceDrop(de); } else { currentPlayList()->forceDrop(de); } return true; } } return QTabWidget::eventFilter(obj, event); }
bool FormFile::eventFilter(QObject *watched, QEvent *event) { if(watched == ui->lvServer) { if(event->type() == QEvent::DragEnter) { QDragEnterEvent* dee = dynamic_cast<QDragEnterEvent*>(event); dee->acceptProposedAction(); return true; } else if(event->type() == QEvent::Drop) { QDropEvent* de = dynamic_cast<QDropEvent*>(event); QList<QUrl>urls = de->mimeData()->urls(); if(urls.isEmpty()) { return true; } QString path = urls.first().toLocalFile(); //上传文件 updateFile(path, path.split("/").last()); return true; } } return QWidget::eventFilter(watched, event); }
bool DropFilter::eventFilter(QObject *obj, QEvent *event) { if( event->type() == QEvent::DragEnter) { QDragEnterEvent *dragEvent=dynamic_cast< QDragEnterEvent* >(event); if (dragEvent->mimeData()->hasFormat("text/plain")) { QString data = dragEvent->mimeData()->text(); dragEvent->acceptProposedAction(); } } else if (event->type() == QEvent::Drop ) { QDropEvent* dropEvent = dynamic_cast< QDropEvent* >(event); QString data = dropEvent->mimeData()->text(); ::fwServices::ObjectMsg::sptr message = ::fwServices::ObjectMsg::New(); message->addEvent("DROPPED_UUID", ::fwData::String::New(data.toStdString())); ::fwServices::IService::sptr service = m_service.lock(); ::fwServices::IEditionService::notify( service, service->getObject< ::fwData::Object >(), message ); } else { // standard event processing return QObject::eventFilter(obj, event); } return true; }
bool AlgorithmRunner::eventFilter(QObject *obj, QEvent *ev) { bool draggableObject = obj == _ui->favoritesBox->widget() || _favorites.contains(dynamic_cast<AlgorithmRunnerItem *>(obj)); if (ev->type() == QEvent::Paint) { if (obj == _ui->favoritesBox->widget() && _favorites.empty()) { QPainter painter(_ui->favoritesBox->widget()); QPixmap px((_ui->favoritesBox->_droppingFavorite ? ":/tulip/graphperspective/icons/32/favorite.png" : ":/tulip/graphperspective/icons/32/favorite-empty.png")); painter.drawPixmap(_ui->favoritesBox->widget()->width() - px.width() - 8, 8, px); QFont f; f.setItalic(true); painter.setFont(f); painter.setBrush(QColor(107, 107, 107)); painter.setPen(QColor(107, 107, 107)); painter.drawText(0, 8 + (px.height() - 12) / 2, _ui->favoritesBox->widget()->width(), 65535, /*Qt::AlignHCenter | Qt::AlignTop |*/ Qt::TextWordWrap, "Put your favorite algorithms here"); } } else if ((ev->type() == QEvent::DragEnter || ev->type() == QEvent::DragMove) && draggableObject) { QDropEvent *dropEv = static_cast<QDropEvent *>(ev); if (dynamic_cast<const AlgorithmMimeType *>(dropEv->mimeData()) != nullptr) { _ui->favoritesBox->_droppingFavorite = true; ev->accept(); _ui->favoritesBox->repaint(); } return true; } else if (ev->type() == QEvent::DragLeave && draggableObject) { _ui->favoritesBox->_droppingFavorite = false; _ui->favoritesBox->repaint(); } else if (ev->type() == QEvent::Drop && draggableObject) { QDropEvent *dropEv = static_cast<QDropEvent *>(ev); const AlgorithmMimeType *mime = dynamic_cast<const AlgorithmMimeType *>(dropEv->mimeData()); if (mime != nullptr) addFavorite(mime->algorithm(), mime->params()); _ui->favoritesBox->_droppingFavorite = false; _ui->favoritesBox->repaint(); } return false; }
/**************************************************************************** ** ** Copyright (C) 2015 ** ** This file is generated by the Magus toolkit ** ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." ** ****************************************************************************/ // Include #include <QHBoxLayout> #include <QVBoxLayout> #include <QMessageBox> #include <QHeaderView> #include <QEvent> #include <QPixmap> #include <QImage> #include <QMimeData> #include <QTableWidgetItem> #include <QTreeWidgetItem> #include "tool_layerwidget.h" namespace Magus { //****************************************************************************/ QtLayerWidget::QtLayerWidget(const QString& iconDir, QtSceneViewWidget* sceneViewWidget, QWidget* parent) : QWidget(parent) { setWindowTitle(QString("Layers")); QHBoxLayout* mainLayout = new QHBoxLayout; QVBoxLayout* tableLayout = new QVBoxLayout; mIconDir = iconDir; mLayerIdCounter = 1; mSceneViewWidget = sceneViewWidget; mListenToSceneViewWidget = 0; mListenToSceneId = 0; mListenToDropEvents = true; mListenToDeleteEvents = true; // Create table mTable = new QTableWidget(0, 3, this); mTable->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); mTable->setEditTriggers(QAbstractItemView::NoEditTriggers); mTable->setAcceptDrops(true); mTable->setShowGrid(false); mTable->viewport()->installEventFilter(this); mTable->setColumnWidth(TOOL_LAYER_COLUMN_ICON, 2 * TOOL_LAYER_ICON_WIDTH); mTable->setColumnWidth(TOOL_LAYER_COLUMN_NAME, TOOL_LAYER_NAME_WIDTH); mTable->setColumnWidth(TOOL_LAYER_COLUMN_VISIBILITY, 2 * TOOL_LAYER_ICON_WIDTH); mTable->setSelectionBehavior(QAbstractItemView::SelectRows); setStyleSheet("QLineEdit{padding: 0 0px; margin-left: 0px; margin-right: 0px; max-height: 28px; height: 28px;}"); connect(mTable, SIGNAL(clicked(QModelIndex)), this, SLOT(tableClicked(QModelIndex))); // Set headers QStringList headers; headers << tr("Layer") << tr("") << tr("Visibility"); mTable->setHorizontalHeaderLabels(headers); QFont font; font.setBold(true); mTable->horizontalHeader()->setFont(font); // Contextmenu setContextMenuPolicy(Qt::CustomContextMenu); mContextMenu = new QMenu(mTable); mContextMenu->addAction(new QAction(TOOL_LAYER_ACTION_CREATE_LAYER, mTable)); mContextMenu->addAction(new QAction(TOOL_LAYER_ACTION_DELETE_LAYER, mTable)); mContextMenu->addAction(new QAction(TOOL_LAYER_ACTION_RENAME_LAYER, mTable)); mContextMenu->addAction(new QAction(TOOL_LAYER_ACTION_ALL_VISIBLE, mTable)); //mContextMenu->addAction(new QAction(QString("TEST"), mTable)); connect(mContextMenu, SIGNAL(triggered(QAction*)), this, SLOT(contextMenuItemSelected(QAction*))); // Layout tableLayout->addWidget(mTable); mainLayout->addLayout(tableLayout); setLayout(mainLayout); } //****************************************************************************/ QtLayerWidget::~QtLayerWidget(void) { QVector<QtLayer*>::iterator it; for (it = mLayerVec.begin(); it != mLayerVec.end(); ++it) delete *it; mLayerVec.clear(); // The table is automatically deleted when this widget is deleted } //****************************************************************************/ bool QtLayerWidget::eventFilter(QObject* object, QEvent* event) { QMouseEvent* mouseEvent = (QMouseEvent*) event; switch ((int) event->type()) { case QEvent::MouseButtonPress: mouseClickHandler(mouseEvent); break; case QEvent::MouseButtonDblClick: mouseDblClickHandler(mouseEvent); break; case QEvent::Drop: dropHandler(object, event); break; } return QObject::eventFilter(object, event); } //****************************************************************************/ void QtLayerWidget::tableClicked(QModelIndex index) { // Toggle visibility int row = index.row(); int col = index.column(); QtLayer* layer = mLayerVec.at(row); if (col == TOOL_LAYER_COLUMN_VISIBILITY) { if (layer->visible == true) updateVisibilityIcon(row, false); else updateVisibilityIcon(row, true); } // Set associated sceneview to visible (if mSceneView available) if (mSceneViewWidget) mSceneViewWidget->setSceneViewVisible(layer->layerId); // Signal that layer is selected emit layerSelected(layer->layerId, layer->name); } //****************************************************************************/ void QtLayerWidget::mouseClickHandler(QMouseEvent* event) { switch ((int) event->button()) { case Qt::LeftButton: { // TODO } break; case Qt::RightButton: { QPoint pos; pos.setX(event->screenPos().x()); pos.setY(event->screenPos().y()); mContextMenu->popup(pos); } break; } } //****************************************************************************/ void QtLayerWidget::mouseDblClickHandler(QMouseEvent* event) { switch ((int) event->button()) { case Qt::LeftButton: { if (mTable->currentColumn() == TOOL_LAYER_COLUMN_NAME) { QTableWidgetItem* item = mTable->currentItem(); if (item->column() == TOOL_LAYER_COLUMN_NAME) { // Its the name; edit it mTable->editItem(item); } } } break; } } //****************************************************************************/ void QtLayerWidget::dropHandler(QObject* object, QEvent* event) { event->accept(); if (!mListenToDropEvents) return; if (!mListenToSceneViewWidget) return; // Determine whether the data was from an abstractitem modellist QDropEvent* dropEvent = static_cast<QDropEvent*>(event); const QMimeData* mimeData = dropEvent->mimeData(); QString mimeType("application/x-qabstractitemmodeldatalist"); if (!mimeData->hasFormat(mimeType)) return; // Do not use the mimeData to retrieve the sceneview tree item, because a standard model is used, // which does not return the data that is needed. // Use the data of the selected item in the sceneview (mListenToSceneId) as an alternative. if (mTable->rowCount() > 0 && mSceneViewWidget) { // Get the dropped item (this is the currently selected item of mListenToSceneId in widget mListenToSceneViewWidget) QTreeWidgetItem* item = mListenToSceneViewWidget->getCurrentItem(mListenToSceneId); if (item) { // The layerId of the selected layer = the sceneId of the visible sceneview tree in mSceneViewWidget // The currently selected group in the mListenToSceneViewWidget = the destination group of mSceneViewWidget int layerId = getCurrentLayerId(); int groupId = mListenToSceneViewWidget->getCurrentGroupId(item); // 1. Add the group; this is ignored if the group is already available QtAssetGroup assetGroupInfo = mListenToSceneViewWidget->getGroupInfo(groupId); mSceneViewWidget->addGroupToSceneView(layerId, assetGroupInfo.groupIcon, groupId, assetGroupInfo.groupName, false); // 2. Determine the item type and add either the asset or all assets in a group if (mListenToSceneViewWidget->itemIsGroup(item)) { // The dropped item is a GROUP // Add all the items of the source group to the destination group QVector<QTreeWidgetItem*> assetVec = mListenToSceneViewWidget->getAssetItemsOfGroup(mListenToSceneId, groupId); foreach (QTreeWidgetItem* assetItem, assetVec) { mSceneViewWidget->addAssetToSceneView(layerId, groupId, mSceneViewWidget->getAssetIdOfAssetItem(assetItem), assetItem->text(0)); } }
bool CloudView::eventFilter(QObject *obj, QEvent *event) { if (obj == mHeader) { static QPoint oldPos; if (event->type() == QEvent::MouseButtonPress) { QMouseEvent *ev = (QMouseEvent *)event; oldPos = ev->globalPos(); return true; } else if (event->type() == QEvent::MouseMove) { QMouseEvent *ev = (QMouseEvent *)event; const QPoint delta = ev->globalPos() - oldPos; MainWindow *win = seafApplet->mainWindow(); win->move(win->x() + delta.x(), win->y() + delta.y()); oldPos = ev->globalPos(); return true; } } else if (obj == mDropArea) { if (event->type() == QEvent::DragEnter) { QDragEnterEvent *ev = (QDragEnterEvent *)event; if (ev->mimeData()->hasUrls() && ev->mimeData()->urls().size() == 1) { const QUrl url = ev->mimeData()->urls().at(0); if (url.scheme() == "file") { QString path = url.toLocalFile(); #if defined(Q_OS_MAC) && (QT_VERSION <= QT_VERSION_CHECK(5, 4, 0)) path = utils::mac::fix_file_id_url(path); #endif if (QFileInfo(path).isDir()) { ev->acceptProposedAction(); } } } return true; } else if (event->type() == QEvent::Drop) { QDropEvent *ev = (QDropEvent *)event; const QUrl url = ev->mimeData()->urls().at(0); QString path = url.toLocalFile(); #if defined(Q_OS_MAC) && (QT_VERSION <= QT_VERSION_CHECK(5, 4, 0)) path = utils::mac::fix_file_id_url(path); #endif ev->setDropAction(Qt::CopyAction); ev->accept(); showCreateRepoDialog(path); return true; } } return QWidget::eventFilter(obj, event); }
bool CloudView::eventFilter(QObject *obj, QEvent *event) { if (obj == mHeader) { static QPoint oldPos; if (event->type() == QEvent::MouseButtonPress) { QMouseEvent *ev = (QMouseEvent *)event; oldPos = ev->globalPos(); return true; } else if (event->type() == QEvent::MouseMove) { QMouseEvent *ev = (QMouseEvent *)event; const QPoint delta = ev->globalPos() - oldPos; MainWindow *win = seafApplet->mainWindow(); win->move(win->x() + delta.x(), win->y() + delta.y()); oldPos = ev->globalPos(); return true; } } else if (obj == mDropArea) { if (event->type() == QEvent::DragEnter) { QDragEnterEvent *ev = (QDragEnterEvent *)event; if (ev->mimeData()->hasUrls() && ev->mimeData()->urls().size() == 1) { const QUrl url = ev->mimeData()->urls().at(0); if (url.isLocalFile()) { QString path = url.toLocalFile(); if (QFileInfo(path).isDir()) { ev->acceptProposedAction(); } } } return true; } else if (event->type() == QEvent::Drop) { QDropEvent *ev = (QDropEvent *)event; const QUrl url = ev->mimeData()->urls().at(0); QString path = url.toLocalFile(); showCreateRepoDialog(path); return true; } } return QWidget::eventFilter(obj, event); }
bool SessionListWidget::event(QEvent *event) { #ifndef QUTIM_MOBILE_UI if (event->type() == QEvent::ToolTip) { if (QHelpEvent *help = static_cast<QHelpEvent*>(event)) { int index = indexAt(help->pos()).row(); if (index != -1) { ChatUnit *unit = session(index)->getUnit(); ToolTip::instance()->showText(help->globalPos(), unit, this); return true; } } } else if (event->type() == QEvent::DragEnter) { QDragEnterEvent *dragEvent = static_cast<QDragEnterEvent*>(event); if (const MimeObjectData *data = qobject_cast<const MimeObjectData*>(dragEvent->mimeData())) { ChatUnit *u = qobject_cast<ChatUnit*>(data->object()); if (u) dragEvent->acceptProposedAction(); } return true; } else if (event->type() == QEvent::Drop) { QDropEvent *dropEvent = static_cast<QDropEvent*>(event); if (const MimeObjectData *mimeData = qobject_cast<const MimeObjectData*>(dropEvent->mimeData())) { if (ChatUnit *u = qobject_cast<ChatUnit*>(mimeData->object())) { ChatLayerImpl::get(u,true)->activate(); dropEvent->setDropAction(Qt::CopyAction); dropEvent->accept(); return true; } } } else #endif if (event->type() == QEvent::ContextMenu) { QContextMenuEvent *ev = static_cast<QContextMenuEvent*>(event); ChatSessionImpl *s = session(row(itemAt(ev->pos()))); if(s) { s->unit()->showMenu(ev->globalPos()); return true; } } return QListWidget::event(event); }
bool AssemblyBrowser::eventFilter(QObject* o, QEvent* e) { if(o == ui) { if (e->type() == QEvent::DragEnter || e->type() == QEvent::Drop) { QDropEvent* de = (QDropEvent*)e; const QMimeData* md = de->mimeData(); const GObjectMimeData* gomd = qobject_cast<const GObjectMimeData*>(md); if (gomd != NULL) { if (e->type() == QEvent::DragEnter) { de->acceptProposedAction(); } else { QApplication::changeOverrideCursor(Qt::ArrowCursor);//setting arrow cursor on Linux QString err = tryAddObject(gomd->objPtr.data()); if(!err.isEmpty()) { QMessageBox::critical(ui, tr("Error!"), err); } } } } } return false; }
bool ArticleViewPrivate::eventFilter(QObject * obj, QEvent * event) { //qDebug() << "eventFilter" << obj << event; const AbstractBibliographicModel * model = qobject_cast< const AbstractBibliographicModel * >(view ? origin(view->model()) : 0); // Only filter the view's events if (model && obj == view->viewport()) { switch (event->type()) { case QEvent::DragMove: case QEvent::DragEnter: { QDropEvent * e = static_cast< QDropEvent * >(event); if ((dropping = model->acceptsDrop(e->mimeData()))) { view->viewport()->update(); e->accept(); } else { e->ignore(); } //qDebug() << "---" << dropping; return true; break; } case QEvent::DragLeave: dropping = false; view->viewport()->update(); break; case QEvent::Drop: dropping = false; view->viewport()->update(); break; default: break; } } return QObject::eventFilter(obj, event); }
bool EventFilter::eventFilter(QObject *watched, QEvent *event) { Q_UNUSED(watched); AVPlayer *player = static_cast<AVPlayer*>(parent()); if (!player || !player->renderer() || !player->renderer()->widget()) return false; if (qobject_cast<QWidget*>(watched) != player->renderer()->widget()) { return false; } #ifndef QT_NO_DYNAMIC_CAST //dynamic_cast is defined as a macro to force a compile error if (player->renderer() != dynamic_cast<VideoRenderer*>(watched)) { // return false; } #endif QEvent::Type type = event->type(); switch (type) { case QEvent::KeyPress: { QKeyEvent *key_event = static_cast<QKeyEvent*>(event); int key = key_event->key(); Qt::KeyboardModifiers modifiers = key_event->modifiers(); switch (key) { case Qt::Key_C: //capture player->captureVideo(); break; case Qt::Key_N: //check playing? player->playNextFrame(); break; case Qt::Key_P: player->play(); break; case Qt::Key_Q: case Qt::Key_Escape: qApp->quit(); break; case Qt::Key_S: player->stop(); //check playing? break; case Qt::Key_Space: //check playing? qDebug("isPaused = %d", player->isPaused()); player->pause(!player->isPaused()); break; case Qt::Key_F: { //TODO: move to gui QWidget *w = qApp->activeWindow(); if (!w) return false; if (w->isFullScreen()) w->showNormal(); else w->showFullScreen(); } break; case Qt::Key_Up: { AudioOutput *ao = player->audio(); if (modifiers == Qt::ControlModifier) { qreal s = player->speed(); if (s < 1.4) s += 0.02; else s += 0.05; if (qAbs<qreal>(s-1.0) <= 0.01) s = 1.0; player->setSpeed(s); return true; } if (ao && ao->isAvailable()) { qreal v = player->audio()->volume(); if (v > 0.5) v += 0.1; else if (v > 0.1) v += 0.05; else v += 0.025; player->audio()->setVolume(v); qDebug("vol = %.3f", player->audio()->volume()); } } break; case Qt::Key_Down: { AudioOutput *ao = player->audio(); if (modifiers == Qt::ControlModifier) { qreal s = player->speed(); if (s < 1.4) s -= 0.02; else s -= 0.05; if (qAbs<qreal>(s-1.0) <= 0.01) s = 1.0; s = qMax<qreal>(s, 0.0); player->setSpeed(s); return true; } if (ao && ao->isAvailable()) { qreal v = player->audio()->volume(); if (v > 0.5) v -= 0.1; else if (v > 0.1) v -= 0.05; else v -= 0.025; player->audio()->setVolume(v); qDebug("vol = %.3f", player->audio()->volume()); } } break; case Qt::Key_O: { if (modifiers == Qt::ControlModifier) { //TODO: emit a signal so we can use custome dialogs? openLocalFile(); } else/* if (m == Qt::NoModifier) */{ emit showNextOSD(); } } break; case Qt::Key_Left: qDebug("<-"); player->seekBackward(); break; case Qt::Key_Right: qDebug("->"); player->seekForward(); break; case Qt::Key_M: if (player->audio()) { player->audio()->setMute(!player->audio()->isMute()); } break; case Qt::Key_R: { VideoRenderer* renderer = player->renderer(); VideoRenderer::OutAspectRatioMode r = renderer->outAspectRatioMode(); renderer->setOutAspectRatioMode(VideoRenderer::OutAspectRatioMode(((int)r+1)%2)); } break; case Qt::Key_T: { QWidget *w = qApp->activeWindow(); if (!w) return false; Qt::WindowFlags wf = w->windowFlags(); if (wf & Qt::WindowStaysOnTopHint) { qDebug("Window not stays on top"); w->setWindowFlags(wf & ~Qt::WindowStaysOnTopHint); } else { qDebug("Window stays on top"); w->setWindowFlags(wf | Qt::WindowStaysOnTopHint); } //call setParent() when changing the flags, causing the widget to be hidden w->show(); } break; case Qt::Key_F1: help(); break; default: return false; } break; } case QEvent::DragEnter: case QEvent::DragMove: { QDropEvent *e = static_cast<QDropEvent*>(event); e->acceptProposedAction(); } break; case QEvent::Drop: { QDropEvent *e = static_cast<QDropEvent*>(event); QString path = e->mimeData()->urls().first().toLocalFile(); player->stop(); player->load(path); player->play(); e->acceptProposedAction(); } break; case QEvent::GraphicsSceneContextMenu: { QGraphicsSceneContextMenuEvent *e = static_cast<QGraphicsSceneContextMenuEvent*>(event); showMenu(e->screenPos()); } break; case QEvent::ContextMenu: { QContextMenuEvent *e = static_cast<QContextMenuEvent*>(event); showMenu(e->globalPos()); } break; default: return false; } return true; //false: for text input }
// TODO *** drop improvements *** // open submenus on drop interactions bool KBookmarkBar::eventFilter( QObject *, QEvent *e ) { if (d->m_filteredToolbar) return false; // todo: make this limit the actions if ( e->type() == QEvent::DragLeave ) { removeTempSep(); } else if ( e->type() == QEvent::Drop ) { removeTempSep(); QDropEvent *dev = static_cast<QDropEvent*>( e ); QDomDocument doc; QList<KBookmark> list = KBookmark::List::fromMimeData( dev->mimeData(), doc ); if ( list.isEmpty() ) return false; if (list.count() > 1) kWarning(7043) << "Sorry, currently you can only drop one address " "onto the bookmark bar!"; KBookmark toInsert = list.first(); KBookmarkGroup parentBookmark = getToolbar(); if(d->m_sepIndex == 0) { KBookmark newBookmark = parentBookmark.addBookmark(toInsert.fullText(), toInsert.url() ); parentBookmark.moveBookmark( newBookmark, KBookmark() ); m_pManager->emitChanged( parentBookmark ); return true; } else { KBookmark after = parentBookmark.first(); for(int i=0; i < d->m_sepIndex - 1 ; ++i) after = parentBookmark.next(after); KBookmark newBookmark = parentBookmark.addBookmark(toInsert.fullText(), toInsert.url() ); parentBookmark.moveBookmark( newBookmark, after ); m_pManager->emitChanged( parentBookmark ); return true; } } else if ( e->type() == QEvent::DragMove || e->type() == QEvent::DragEnter ) { QDragMoveEvent *dme = static_cast<QDragMoveEvent*>( e ); if (!KBookmark::List::canDecode( dme->mimeData() )) return false; //cache text, save positions (inserting the temporary widget changes the positions) if(e->type() == QEvent::DragEnter) { QDomDocument doc; const QList<KBookmark> list = KBookmark::List::fromMimeData( dme->mimeData(), doc ); if ( list.isEmpty() ) return false; d->tempLabel = list.first().url().pathOrUrl(); d->widgetPositions.clear(); for (int i = 0; i < m_toolBar->actions().count(); ++i) if (QWidget* button = m_toolBar->widgetForAction(m_toolBar->actions()[i])) { if(m_toolBar->orientation() == Qt::Horizontal) { if(QApplication::isLeftToRight()) { d->widgetPositions.push_back(button->geometry().right()); } else { d->widgetPositions.push_back(button->geometry().left()); } } else { d->widgetPositions.push_back(button->geometry().bottom()); } } } bool accept = handleToolbarDragMoveEvent(dme->pos(), d->m_actions, d->tempLabel); if (accept) { dme->accept(); return true; //Really? } } return false; }
bool ClassSpaceChecker::eventFilter(QObject *object, QEvent *evt) { if(evt->type() == QEvent::FocusOut) { if(object == ui.tableWidgetResult) { ui.lineEdit_Result->setText(prevTotalResultStr_); } return QMainWindow::eventFilter(object, evt); } if(object == ui.comboBox_JarFile || object == ui.lineEdit_MapFile ) { if(evt->type() == QEvent::DragEnter) { QDragEnterEvent *e = (QDragEnterEvent*)evt; const QMimeData *mimeData = e->mimeData(); if (mimeData->hasUrls()) { int cnt = 0; QList<QUrl> urlList = mimeData->urls(); for (int i = 0; i < urlList.size(); ++i) { QString path = urlList.at(i).toLocalFile(); if( !QFileInfo(path).isFile() ) continue; if(path.indexOf(".jar", 0, Qt::CaseInsensitive) < 0 && path.indexOf(".zip", 0, Qt::CaseInsensitive) < 0 && path.indexOf(".txt", 0, Qt::CaseInsensitive) < 0 ) continue; if(urlList.size() == 1) { if(object == ui.comboBox_JarFile) { if(path.indexOf(".jar", 0, Qt::CaseInsensitive) < 0 && path.indexOf(".zip", 0, Qt::CaseInsensitive) < 0 ) continue; } else if(object == ui.lineEdit_MapFile) { if(path.indexOf(".txt", 0, Qt::CaseInsensitive) < 0) continue; } } cnt++; } if( cnt > 0 ) e->acceptProposedAction(); } qDebug() << evt << mimeData->text(); } else if(evt->type() == QEvent::DragLeave) { QDragLeaveEvent *e = (QDragLeaveEvent*)evt; e->accept(); } else if(evt->type() == QEvent::DragMove) { QDragMoveEvent *e = (QDragMoveEvent*)evt; e->acceptProposedAction(); } else if(evt->type() == QEvent::Drop) { QDropEvent *e = (QDropEvent*)evt; const QMimeData* mimeData = e->mimeData(); if (mimeData->hasUrls()) { QList<QUrl> urlList = mimeData->urls(); for (int i = 0; i < urlList.size(); ++i) { QString path = urlList.at(i).toLocalFile(); if(path.indexOf(".txt", 0, Qt::CaseInsensitive) >= 0) ui.lineEdit_MapFile->setText(path); if(path.indexOf(".jar", 0, Qt::CaseInsensitive) >= 0 || path.indexOf(".zip", 0, Qt::CaseInsensitive) >= 0) { checkAndJarFilePreset(path); } } } } } return QMainWindow::eventFilter(object, evt); }
bool PlayerWidget::eventFilter(QObject *object, QEvent *event) { if(object == m_layeredWidget) { if(event->type() == QEvent::DragEnter) { QDragEnterEvent *dragEnterEvent = static_cast<QDragEnterEvent *>(event); KUrl::List urls = KUrl::List::fromMimeData(dragEnterEvent->mimeData()); if(!urls.isEmpty()) dragEnterEvent->accept(); else dragEnterEvent->ignore(); return true; } else if(event->type() == QEvent::DragMove) { return true; // eat event } else if(event->type() == QEvent::Drop) { QDropEvent *dropEvent = static_cast<QDropEvent *>(event); KUrl::List urls = KUrl::List::fromMimeData(dropEvent->mimeData()); if(!urls.isEmpty()) { for(KUrl::List::ConstIterator it = urls.begin(), end = urls.end(); it != end; ++it) { const KUrl &url = *it; if(url.protocol() != "file") continue; app()->openVideo(url); break; } } return true; // eat event } else if(event->type() == QEvent::KeyPress) { // NOTE: when on full screen mode, the keyboard input is received but // for some reason it doesn't trigger the correct actions automatically // so we process the event and handle the issue ourselves. QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event); return app()->triggerAction(QKeySequence((keyEvent->modifiers() & ~Qt::KeypadModifier) + keyEvent->key())); } else if(event->type() == QEvent::MouseMove) { QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event); if(mouseEvent->globalPos() != m_currentCursorPos) { m_currentCursorPos = mouseEvent->globalPos(); if(m_layeredWidget->cursor().shape() == Qt::BlankCursor) m_layeredWidget->unsetCursor(); if(m_fullScreenControls->isAttached()) m_fullScreenControls->toggleVisible(true); } } } else if(object == m_infoControlsGroupBox || object->parent() == m_infoControlsGroupBox) { if(event->type() != QEvent::MouseButtonRelease) return QWidget::eventFilter(object, event); QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event); if(mouseEvent->button() != Qt::RightButton) return QWidget::eventFilter(object, event); KMenu menu; QAction *action = menu.addAction(i18n("Show editable position control")); action->setCheckable(true); action->setChecked(app()->playerConfig()->showPositionTimeEdit()); if(menu.exec(mouseEvent->globalPos()) == action) app()->playerConfig()->toggleShowPositionTimeEdit(); return true; // eat event } return QWidget::eventFilter(object, event); }
bool canDropToTab(const QDropEvent &event) { const auto &data = *event.mimeData(); return data.hasFormat(mimeItems) || data.hasText() || data.hasImage() || data.hasUrls(); }
bool HashBox::eventFilter(QObject* object, QEvent* event) { if (object == dropWidget) { if (event->type() == QEvent::DragEnter) { QDragEnterEvent* dragEnterEvent = static_cast<QDragEnterEvent*>(event); if (dragEnterEvent) { /* print out mimeType */ showFormats("HashBox::dragEnterEvent", dragEnterEvent->mimeData()->formats()); if (dragEnterEvent->mimeData()->hasUrls()) { std::cerr << "HashBox::dragEnterEvent() Accepting Urls" << std::endl; dragEnterEvent->acceptProposedAction(); } else { std::cerr << "HashBox::dragEnterEvent() No Urls" << std::endl; } } } else if (event->type() == QEvent::Drop) { QDropEvent* dropEvent = static_cast<QDropEvent*>(event); if (dropEvent) { if (Qt::CopyAction & dropEvent->possibleActions()) { /* print out mimeType */ showFormats("HashBox::dropEvent", dropEvent->mimeData()->formats()); QStringList files; if (dropEvent->mimeData()->hasUrls()) { std::cerr << "HashBox::dropEvent() Urls:" << std::endl; QList<QUrl> urls = dropEvent->mimeData()->urls(); QList<QUrl>::iterator uit; for (uit = urls.begin(); uit != urls.end(); ++uit) { QString localpath = uit->toLocalFile(); std::cerr << "Whole URL: " << uit->toString().toStdString() << std::endl; std::cerr << "or As Local File: " << localpath.toStdString() << std::endl; if (localpath.isEmpty() == false) { //Check that the file does exist and is not a directory QDir dir(localpath); if (dir.exists()) { std::cerr << "HashBox::dropEvent() directory not accepted." << std::endl; QMessageBox mb(tr("Drop file error."), tr("Directory can't be dropped, only files are accepted."), QMessageBox::Information, QMessageBox::Ok, 0, 0, this); mb.exec(); } else if (QFile::exists(localpath)) { files.push_back(localpath); } else { std::cerr << "HashBox::dropEvent() file does not exists."<< std::endl; QMessageBox mb(tr("Drop file error."), tr("File not found or file name not accepted."), QMessageBox::Information, QMessageBox::Ok, 0, 0, this); mb.exec(); } } } } addAttachments(files,mDefaultTransferFlags); dropEvent->setDropAction(Qt::CopyAction); dropEvent->accept(); } else { std::cerr << "HashBox::dropEvent() Rejecting uncopyable DropAction" << std::endl; } } } } // pass the event on to the parent class return QScrollArea::eventFilter(object, event); }
bool FileDialogEventCatcher::eventFilter(QObject *o, QEvent *e) { if (e->type() == QEvent::KeyPress) { QKeyEvent *keyEvent = static_cast<QKeyEvent *>(e); switch (keyEvent->key()) { case Qt::Key_Escape: emit escapePressed(); return true; case Qt::Key_D: if (keyEvent->modifiers() & Qt::ControlModifier) { emit desktopPressed(); return true; } break; case Qt::Key_H: if (keyEvent->modifiers() & (Qt::ControlModifier|Qt::ShiftModifier)) { emit homePressed(); return true; } break; case Qt::Key_Up: if (keyEvent->modifiers() & Qt::ControlModifier) { emit parentPressed(); return true; } break; case Qt::Key_Down: if (keyEvent->modifiers() & Qt::ControlModifier) { emit enterSelectedPressed(); return true; } break; } } else if (e->type() == QEvent::DragEnter) { e->accept(); return true; } else if (e->type() == QEvent::Drop) { QDropEvent *dropEvent = static_cast<QDropEvent *>(e); if (dropEvent) { if ( dropEvent->mimeData()->hasFormat("text/uri-list")) { QString fileUrl; QList<QUrl> fileUrls = dropEvent->mimeData()->urls(); if (fileUrls.count()>0) { fileUrl = fileUrls[0].toLocalFile(); if (fileUrls[0].isLocalFile()) { emit dropLocation(fileUrl); } } } } e->accept(); return true; } return QObject::eventFilter(o, e); }
bool BookmarkToolBar::eventFilter(QObject *watched, QEvent *event) { if (m_currentMenu && m_currentMenu->isVisible() && !m_currentMenu->rect().contains(m_currentMenu->mapFromGlobal(QCursor::pos()))) { // To switch root folders as in a menubar KBookmarkActionMenu* act = dynamic_cast<KBookmarkActionMenu *>(actionAt(mapFromGlobal(QCursor::pos()))); if (event->type() == QEvent::MouseMove && act && act->menu() != m_currentMenu) { m_currentMenu->hide(); QPoint pos = mapToGlobal(widgetForAction(act)->pos()); act->menu()->popup(QPoint(pos.x(), pos.y() + widgetForAction(act)->height())); } else if (event->type() == QEvent::MouseButtonPress && act) { m_currentMenu->hide(); } return QObject::eventFilter(watched, event); } switch (event->type()) { case QEvent::Show: { if (!m_filled) { BookmarkManager::self()->fillBookmarkBar(this); m_filled = true; } } break; case QEvent::ActionRemoved: { QActionEvent *actionEvent = static_cast<QActionEvent*>(event); if (actionEvent && actionEvent->action() != m_dropAction) { QWidget *widget = widgetForAction(actionEvent->action()); if (widget) { widget->removeEventFilter(this); } } } break; case QEvent::ParentChange: { QActionEvent *actionEvent = static_cast<QActionEvent*>(event); if (actionEvent && actionEvent->action() != m_dropAction) { QWidget *widget = widgetForAction(actionEvent->action()); if (widget) { widget->removeEventFilter(this); } } } break; case QEvent::DragEnter: { QDragEnterEvent *dragEvent = static_cast<QDragEnterEvent*>(event); if (dragEvent->mimeData()->hasFormat(BookmarkManager::bookmark_mime_type()) || dragEvent->mimeData()->hasFormat("text/uri-list") || dragEvent->mimeData()->hasFormat("text/plain")) { QFrame* dropIndicatorWidget = new QFrame(this); dropIndicatorWidget->setFrameShape(QFrame::VLine); m_dropAction = insertWidget(actionAt(dragEvent->pos()), dropIndicatorWidget); dragEvent->accept(); } } break; case QEvent::DragLeave: { QDragLeaveEvent *dragEvent = static_cast<QDragLeaveEvent*>(event); if (m_checkedAction) { m_checkedAction->setCheckable(false); m_checkedAction->setChecked(false); } delete m_dropAction; m_dropAction = 0; dragEvent->accept(); } break; case QEvent::DragMove: { QDragMoveEvent *dragEvent = static_cast<QDragMoveEvent*>(event); if (dragEvent->mimeData()->hasFormat(BookmarkManager::bookmark_mime_type()) || dragEvent->mimeData()->hasFormat("text/uri-list") || dragEvent->mimeData()->hasFormat("text/plain")) { QAction *overAction = actionAt(dragEvent->pos()); KBookmarkActionInterface *overActionBK = dynamic_cast<KBookmarkActionInterface*>(overAction); QWidget *widgetAction = widgetForAction(overAction); if (overAction != m_dropAction && overActionBK && widgetAction && m_dropAction) { removeAction(m_dropAction); if (m_checkedAction) { m_checkedAction->setCheckable(false); m_checkedAction->setChecked(false); } if (!overActionBK->bookmark().isGroup()) { if ((dragEvent->pos().x() - widgetAction->pos().x()) > (widgetAction->width() / 2)) { if (actions().count() > actions().indexOf(overAction) + 1) { insertAction(actions().at(actions().indexOf(overAction) + 1), m_dropAction); } else { addAction(m_dropAction); } } else { insertAction(overAction, m_dropAction); } } else { if ((dragEvent->pos().x() - widgetAction->pos().x()) >= (widgetAction->width() * 0.75)) { if (actions().count() > actions().indexOf(overAction) + 1) { insertAction(actions().at(actions().indexOf(overAction) + 1), m_dropAction); } else { addAction(m_dropAction); } } else if ((dragEvent->pos().x() - widgetAction->pos().x()) <= (widgetAction->width() * 0.25)) { insertAction(overAction, m_dropAction); } else { overAction->setCheckable(true); overAction->setChecked(true); m_checkedAction = overAction; } } dragEvent->accept(); } } } break; case QEvent::Drop: { QDropEvent *dropEvent = static_cast<QDropEvent*>(event); KBookmark bookmark; KBookmarkGroup root = BookmarkManager::self()->manager()->toolbar(); if (m_checkedAction) { m_checkedAction->setCheckable(false); m_checkedAction->setChecked(false); } if (dropEvent->mimeData()->hasFormat(BookmarkManager::bookmark_mime_type())) { QByteArray addresses = dropEvent->mimeData()->data(BookmarkManager::bookmark_mime_type()); bookmark = BookmarkManager::self()->findByAddress(QString::fromLatin1(addresses.data())); if (bookmark.isNull()) return false; } else if (dropEvent->mimeData()->hasFormat("text/uri-list")) { // DROP is URL QString url = dropEvent->mimeData()->urls().at(0).toString(); WebWindow *w = qobject_cast<WebWindow *>(parent()); QString title = url.contains(w->url().url()) ? w->title() : url; bookmark = root.addBookmark(title, url); } else if (dropEvent->mimeData()->hasFormat("text/plain")) { // DROP is TEXT QString url = dropEvent->mimeData()->text(); KUrl u(url); if (u.isValid()) { WebWindow *w = qobject_cast<WebWindow *>(parent()); QString title = url.contains(w->url().url()) ? w->title() : url; bookmark = root.addBookmark(title, url); } } else { return false; } QAction *destAction = actionAt(dropEvent->pos()); if (destAction && destAction == m_dropAction) { if (actions().indexOf(m_dropAction) > 0) { destAction = actions().at(actions().indexOf(m_dropAction) - 1); } else { destAction = actions().at(1); } } if (destAction) { KBookmarkActionInterface *destBookmarkAction = dynamic_cast<KBookmarkActionInterface *>(destAction); QWidget *widgetAction = widgetForAction(destAction); if (destBookmarkAction && !destBookmarkAction->bookmark().isNull() && widgetAction && bookmark.address() != destBookmarkAction->bookmark().address()) { KBookmark destBookmark = destBookmarkAction->bookmark(); if (!destBookmark.isGroup()) { if ((dropEvent->pos().x() - widgetAction->pos().x()) >= (widgetAction->width() / 2)) { root.moveBookmark(bookmark, destBookmark); } else { root.moveBookmark(bookmark, destBookmark.parentGroup().previous(destBookmark)); } } else { if ((dropEvent->pos().x() - widgetAction->pos().x()) >= (widgetAction->width() * 0.75)) { root.moveBookmark(bookmark, destBookmark); } else if ((dropEvent->pos().x() - widgetAction->pos().x()) <= (widgetAction->width() * 0.25)) { root.moveBookmark(bookmark, destBookmark.parentGroup().previous(destBookmark)); } else { destBookmark.toGroup().addBookmark(bookmark); } } BookmarkManager::self()->emitChanged(); } } else { root.deleteBookmark(bookmark); bookmark = root.addBookmark(bookmark); if (dropEvent->pos().x() < widgetForAction(actions().first())->pos().x()) { root.moveBookmark(bookmark, KBookmark()); } BookmarkManager::self()->emitChanged(); } dropEvent->accept(); } break; default: break; } QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event); // These events need to be handled only for Bookmark actions and not the bar if (watched != this && mouseEvent) { switch (event->type()) { case QEvent::MouseButtonPress: // drag handling { QPoint pos = mapFromGlobal(QCursor::pos()); KBookmarkActionInterface *action = dynamic_cast<KBookmarkActionInterface *>(actionAt(pos)); if (action && mouseEvent->button() != Qt::MiddleButton) { m_dragAction = actionAt(pos); m_startDragPos = pos; // The menu is displayed only when the mouse button is released if (action->bookmark().isGroup()) return true; } } break; case QEvent::MouseMove: { int distance = (mapFromGlobal(QCursor::pos()) - m_startDragPos).manhattanLength(); if (!m_currentMenu && distance >= QApplication::startDragDistance()) { startDrag(); } } break; case QEvent::MouseButtonRelease: { QPoint destPos = mapFromGlobal(QCursor::pos()); int distance = (destPos - m_startDragPos).manhattanLength(); KBookmarkActionInterface *action = dynamic_cast<KBookmarkActionInterface *>(actionAt(destPos)); if (action) { if (action->bookmark().isGroup()) { if (mouseEvent->button() == Qt::MiddleButton) { BookmarkManager::self()->owner()->loadBookmarkFolder(action->bookmark()); } else if (distance < QApplication::startDragDistance()) { KBookmarkActionMenu *menu = dynamic_cast<KBookmarkActionMenu *>(actionAt(m_startDragPos)); QPoint actionPos = mapToGlobal(widgetForAction(menu)->pos()); menu->menu()->popup(QPoint(actionPos.x(), actionPos.y() + widgetForAction(menu)->height())); } } else { if (!action->bookmark().isNull() && !action->bookmark().isSeparator()) { if (mouseEvent->button() == Qt::MiddleButton) { BookmarkManager::self()->owner()->loadBookmarkInNewTab(action->bookmark()); } } } } } break; default: break; } } return QObject::eventFilter(watched, event); }
bool BE::Contacts::eventFilter(QObject *o, QEvent *e) { if (o == m_ui->filter) { if (e->type() == QEvent::KeyPress) if (static_cast<QKeyEvent*>(e)->key() == Qt::Key_Down) m_ui->contacts->setFocus(); return false; } if (o == m_ui->contacts) { if (e->type() == QEvent::KeyPress) { QKeyEvent *ke = static_cast<QKeyEvent*>(e); if (ke->key() == Qt::Key_Up && !m_ui->contacts->currentIndex().row()) { m_ui->filter->setFocus(); return true; } else if (ke->key() == Qt::Key_Delete) { removeCurrentContact(); return true; } } return false; } if (!m_currentContact) return false; switch (e->type()) { case QEvent::DragEnter: case QEvent::DragMove: case QEvent::Drop: { if (o != m_ui2->photo) return false; QDropEvent *de = static_cast<QDropEvent*>(e); if (!de->mimeData()) return false; QList<QUrl> urls = de->mimeData()->urls(); if (urls.isEmpty()) return false; QUrl url = urls.first(); if ( #if QT_VERSION >= QT_VERSION_CHECK(4, 8, 0) url.isLocalFile() #else (url.scheme() == QLatin1String("file")) #endif && QImageReader(url.path()).canRead()) { if (e->type() == QEvent::Drop) importPhoto(url.path()); else de->acceptProposedAction(); } return false; } case QEvent::KeyPress: { const int key = static_cast<QKeyEvent*>(e)->key(); if (key == Qt::Key_Delete && o == m_ui2->photo) { // reset photo if (m_currentContact) m_currentContact->setData(QString(), Gui::AbookAddressbook::Photo); m_ui2->photo->setPixmap(m_incognitoPic); } else if (key == Qt::Key_Escape && o != m_ui2->photo) if (QLabel *l = qobject_cast<QLabel*>(o)) { setText(l, l->text()); return true; // prevent closing the dialog! } } default: return false; } return false; }
bool MainWindow::eventFilter(QObject *watched, QEvent *event) { switch (event->type()) { case QEvent::KeyRelease: { QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event); //int mask = Qt::ControlModifier | Qt::ShiftModifier | Qt::AltModifier; //if(keyEvent->modifiers() == mask) //{ //} break; } case QEvent::DragEnter: { QDragEnterEvent *dragEnterEvent = static_cast<QDragEnterEvent*>(event); const QMimeData* mimeData = dragEnterEvent->mimeData(); // check for our needed mime type, here a file or a list of files if (!mimeData->hasUrls()) break; QList<QUrl> urlList = mimeData->urls(); for (int i = 0; i < urlList.size(); ++i) { qDebug() << urlList.at(i).toString(); if (urlList.at(i).toString().endsWith(".torrent")) { dragEnterEvent->acceptProposedAction(); return true; } } break; } case QEvent::Drop: { QDropEvent *dropEvent = static_cast<QDropEvent*>(event); const QMimeData* mimeData = dropEvent->mimeData(); // check for our needed mime type, here a file or a list of files if (!mimeData->hasUrls()) break; QStringList pathList; QList<QUrl> urlList = mimeData->urls(); // extract the local paths of the files for (int i = 0; i < urlList.size(); ++i) { pathList.append(urlList.at(i).toLocalFile()); } //addTorrents(pathList); return true; } default: break; } return QObject::eventFilter(watched, event); }
bool MainWindow::eventFilter(QObject *watched, QEvent *event) { if (watched == ui->iconLabel) { QFileInfo file("icon_create.py"); if(!file.exists()) { trcDebug("icon_create.py does not exist!"); return false; } if (event->type() == QEvent::DragEnter) { // [[2]]: 当拖放时鼠标进入label时, label接受拖放的动作 QDragEnterEvent *dee = dynamic_cast<QDragEnterEvent *>(event); dee->acceptProposedAction(); return true; } else if (event->type() == QEvent::Drop) { // [[3]]: 当放操作发生后, 取得拖放的数据 QDropEvent *de = dynamic_cast<QDropEvent *>(event); QList<QUrl> urls = de->mimeData()->urls(); if (urls.isEmpty()) { return true; } QString path = urls.first().toLocalFile(); // [[4]]: 在label上显示拖放的图片 QImage image(path); // QImage对I/O优化过, QPixmap对显示优化 if (!image.isNull()) { ui->iconLabel->setPixmap(QPixmap::fromImage(image)); QStringList arguments; QFileInfo file(path); arguments<<"icon_create.py"<<file.absolutePath()<<file.fileName(); cmd.start("python",arguments);//非阻塞 int flag = cmd.execute("python",arguments);//阻塞 switch (flag) { case -1: ui->statusBar->showMessage("The process crashes"); break; case -2: ui->statusBar->showMessage("The process cannot be started"); default: ui->statusBar->showMessage("Icon to create success"); break; } } return true; } }else if(watched == ui->screenshotLabel){ QFileInfo file("screenshot_create.py"); if(!file.exists()) { trcDebug("screenshot_create.py does not exist!"); return false; } if (event->type() == QEvent::DragEnter) { // [[2]]: 当拖放时鼠标进入label时, label接受拖放的动作 QDragEnterEvent *dee = dynamic_cast<QDragEnterEvent *>(event); dee->acceptProposedAction(); return true; } else if (event->type() == QEvent::Drop) { // [[3]]: 当放操作发生后, 取得拖放的数据 QDropEvent *de = dynamic_cast<QDropEvent *>(event); QList<QUrl> urls = de->mimeData()->urls(); if (urls.isEmpty()) { return true; } foreach (QUrl file, urls) { QString path = file.toLocalFile(); // [[4]]: 在label上显示拖放的图片 QImage image(path); // QImage对I/O优化过, QPixmap对显示优化 if (!image.isNull()) { ui->screenshotLabel->setPixmap(QPixmap::fromImage(image)); QStringList arguments; QFileInfo file(path); arguments<<"screenshot_create.py"<<file.absolutePath()<<file.fileName(); cmd.execute("python",arguments);//非阻塞 int flag = cmd.execute("python",arguments);//阻塞 switch (flag) { case -1: ui->statusBar->showMessage("The process crashes"); break; case -2: ui->statusBar->showMessage("The process cannot be started"); default: ui->statusBar->showMessage("Icon to create success"); break; } } }