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 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);
}
// 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 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 MainWindow::eventFilter(QObject *object, QEvent *event)
{
if (event->type() == QEvent::DragEnter)
{
QDragEnterEvent *dragEvent = (QDragEnterEvent*)event;
// accept only folders
QList<QUrl> urls = dragEvent->mimeData()->urls();
for (const QUrl url: urls)
{
if (url.isLocalFile())
{
QFileInfo info(url.toLocalFile());
if (info.isFile())
{
return false;
}
}
}
dragEvent->setDropAction(Qt::LinkAction);
dragEvent->acceptProposedAction();
return true;
}
else if (event->type() == QEvent::Drop)
{
QList<QUrl> urls = ((QDropEvent*)event)->mimeData()->urls();
QStringList files;
for (const QUrl url: urls)
{
if (url.isLocalFile())
{
QFileInfo info(url.toLocalFile());
if (info.isFile())
files.append(url.toLocalFile());
else if (info.isDir())
filesList->addFolder(info.absoluteFilePath());
}
}
filesList->addFiles(files);
return true;
}
return QMainWindow::eventFilter(object, 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 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 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 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
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 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);
}