void TestGui::testAddEntry()
{
EntryView* entryView = m_dbWidget->findChild<EntryView*>("entryView");
QAction* entryNewAction = m_mainWindow->findChild<QAction*>("actionEntryNew");
QVERIFY(entryNewAction->isEnabled());
QToolBar* toolBar = m_mainWindow->findChild<QToolBar*>("toolBar");
QWidget* entryNewWidget = toolBar->widgetForAction(entryNewAction);
QVERIFY(entryNewWidget->isVisible());
QVERIFY(entryNewWidget->isEnabled());
QTest::mouseClick(entryNewWidget, Qt::LeftButton);
QCOMPARE(m_dbWidget->currentMode(), DatabaseWidget::EditMode);
EditEntryWidget* editEntryWidget = m_dbWidget->findChild<EditEntryWidget*>("editEntryWidget");
QLineEdit* titleEdit = editEntryWidget->findChild<QLineEdit*>("titleEdit");
QTest::keyClicks(titleEdit, "test");
QDialogButtonBox* editEntryWidgetButtonBox = editEntryWidget->findChild<QDialogButtonBox*>("buttonBox");
QTest::mouseClick(editEntryWidgetButtonBox->button(QDialogButtonBox::Ok), Qt::LeftButton);
QCOMPARE(m_dbWidget->currentMode(), DatabaseWidget::ViewMode);
QModelIndex item = entryView->model()->index(1, 1);
Entry* entry = entryView->entryFromIndex(item);
QCOMPARE(entry->title(), QString("test"));
QCOMPARE(entry->historyItems().size(), 0);
// wait for modified timer
QTRY_COMPARE(m_tabWidget->tabText(m_tabWidget->currentIndex()), QString("%1*").arg(m_orgDbFileName));
QAction* entryEditAction = m_mainWindow->findChild<QAction*>("actionEntryEdit");
QVERIFY(entryEditAction->isEnabled());
QWidget* entryEditWidget = toolBar->widgetForAction(entryEditAction);
QVERIFY(entryEditWidget->isVisible());
QVERIFY(entryEditWidget->isEnabled());
QTest::mouseClick(entryEditWidget, Qt::LeftButton);
QCOMPARE(m_dbWidget->currentMode(), DatabaseWidget::EditMode);
QTest::keyClicks(titleEdit, "something");
QTest::mouseClick(editEntryWidgetButtonBox->button(QDialogButtonBox::Ok), Qt::LeftButton);
QCOMPARE(entry->title(), QString("testsomething"));
QCOMPARE(entry->historyItems().size(), 1);
QTest::mouseClick(entryNewWidget, Qt::LeftButton);
QTest::keyClicks(titleEdit, "something 2");
QTest::mouseClick(editEntryWidgetButtonBox->button(QDialogButtonBox::Ok), Qt::LeftButton);
QTest::mouseClick(entryNewWidget, Qt::LeftButton);
QTest::keyClicks(titleEdit, "something 3");
QTest::mouseClick(editEntryWidgetButtonBox->button(QDialogButtonBox::Ok), Qt::LeftButton);
QTRY_COMPARE(entryView->model()->rowCount(), 4);
}
void TestGui::testSearch()
{
QAction* searchAction = m_mainWindow->findChild<QAction*>("actionSearch");
QVERIFY(searchAction->isEnabled());
QToolBar* toolBar = m_mainWindow->findChild<QToolBar*>("toolBar");
QWidget* searchActionWidget = toolBar->widgetForAction(searchAction);
QVERIFY(searchActionWidget->isVisible());
QVERIFY(searchActionWidget->isEnabled());
QTest::mouseClick(searchActionWidget, Qt::LeftButton);
EntryView* entryView = m_dbWidget->findChild<EntryView*>("entryView");
QLineEdit* searchEdit = m_dbWidget->findChild<QLineEdit*>("searchEdit");
QToolButton* clearSearch = m_dbWidget->findChild<QToolButton*>("clearButton");
QTest::keyClicks(searchEdit, "ZZZ");
QTRY_COMPARE(entryView->model()->rowCount(), 0);
QTest::mouseClick(clearSearch, Qt::LeftButton);
QTest::keyClicks(searchEdit, "some");
QTRY_COMPARE(entryView->model()->rowCount(), 2);
QModelIndex item = entryView->model()->index(0, 1);
QRect itemRect = entryView->visualRect(item);
QTest::mouseClick(entryView->viewport(), Qt::LeftButton, Qt::NoModifier, itemRect.center());
QAction* entryEditAction = m_mainWindow->findChild<QAction*>("actionEntryEdit");
QVERIFY(entryEditAction->isEnabled());
QWidget* entryEditWidget = toolBar->widgetForAction(entryEditAction);
QVERIFY(entryEditWidget->isVisible());
QVERIFY(entryEditWidget->isEnabled());
QTest::mouseClick(entryEditWidget, Qt::LeftButton);
QCOMPARE(m_dbWidget->currentMode(), DatabaseWidget::EditMode);
EditEntryWidget* editEntryWidget = m_dbWidget->findChild<EditEntryWidget*>("editEntryWidget");
QDialogButtonBox* editEntryWidgetButtonBox = editEntryWidget->findChild<QDialogButtonBox*>("buttonBox");
QTest::mouseClick(editEntryWidgetButtonBox->button(QDialogButtonBox::Ok), Qt::LeftButton);
QCOMPARE(m_dbWidget->currentMode(), DatabaseWidget::ViewMode);
QModelIndex item2 = entryView->model()->index(1, 0);
QRect itemRect2 = entryView->visualRect(item2);
QTest::mouseClick(entryView->viewport(), Qt::LeftButton, Qt::NoModifier, itemRect2.center());
QAction* entryDeleteAction = m_mainWindow->findChild<QAction*>("actionEntryDelete");
QWidget* entryDeleteWidget = toolBar->widgetForAction(entryDeleteAction);
QVERIFY(entryDeleteWidget->isVisible());
QVERIFY(entryDeleteWidget->isEnabled());
QTest::mouseClick(entryDeleteWidget, Qt::LeftButton);
QWidget* closeSearchButton = m_dbWidget->findChild<QToolButton*>("closeSearchButton");
QTest::mouseClick(closeSearchButton, Qt::LeftButton);
QCOMPARE(entryView->model()->rowCount(), 1);
}
bool GTUtilsMSAEditorSequenceArea::offsetsVisible(HI::GUITestOpStatus &os) {
QWidget *leftOffsetWidget = GTWidget::findWidget(os, "msa_editor_offsets_view_widget_left");
QWidget *rightOffsetWidget = GTWidget::findWidget(os, "msa_editor_offsets_view_widget_right");
GT_CHECK_RESULT((leftOffsetWidget != NULL) && (rightOffsetWidget != NULL), "offset widgets are NULL", false);
GT_CHECK_RESULT(leftOffsetWidget->isVisible() == rightOffsetWidget->isVisible(), "offset widget visibility states are not the same", false);
return leftOffsetWidget->isVisible();
}
void MainWindowPlugin::onOptionsChanged(const OptionsNode &ANode)
{
if (ANode.path() == OPV_MAINWINDOW_STAYONTOP)
{
#ifdef Q_WS_MAC
setWindowOntop(FMainWindow, ANode.value().toBool());
#else
QWidget *widget = mainWindowTopWidget();
bool show = widget->isVisible();
if (ANode.value().toBool())
widget->setWindowFlags(widget->windowFlags() | Qt::WindowStaysOnTopHint);
else
widget->setWindowFlags(widget->windowFlags() & ~Qt::WindowStaysOnTopHint);
if (show)
showMainWindow();
#endif
}
else if (ANode.path() == OPV_MAINWINDOW_MINIMIZETOTRAY_W7)
{
if (isMinimizeToTray())
{
Options::node(OPV_MAINWINDOW_MINIMIZENOTIFY_SHOWCOUNT).setValue(MINIMIZENOTIFY_MAX_SHOWCOUNT+1);
}
if (FMainWindowBorder)
{
FMainWindowBorder->setMinimizeOnClose(!isMinimizeToTray());
}
if (!isMinimizeToTray() && !mainWindowTopWidget()->isVisible())
{
hideMainWindow();
}
}
}
void TransparentTop::transparentChanged()
{
#ifdef WIN32
if (bCanTransparent){
QWidget *p = static_cast<QWidget*>(parent());
if (*useTransparent){
if (!m_bUseTransparent){
SetWindowLongW(p->winId(), GWL_EXSTYLE, GetWindowLongW(p->winId(), GWL_EXSTYLE) | WS_EX_LAYERED);
SetLayeredWindowAttributes(p->winId(), p->colorGroup().background().rgb(), 255, LWA_ALPHA);
if (p->isVisible())
RedrawWindow(p->winId(), NULL, NULL, RDW_UPDATENOW);
p->installEventFilter(this);
m_bUseTransparent = true;
}
}else{
if (m_bUseTransparent){
SetWindowLongW(p->winId(), GWL_EXSTYLE, GetWindowLongW(p->winId(), GWL_EXSTYLE) & ~WS_EX_LAYERED);
p->removeEventFilter(this);
m_bUseTransparent = false;
}
}
}
#endif
setTransparent();
}
bool
Basic::eventFilter( QObject* object, QEvent *e )
{
QWidget* widget = qobject_cast<QWidget*>(object);
if (!(widget && widget->isVisible()))
return false;
switch (e->type())
{
case QEvent::MouseMove:
case QEvent::Timer:
case QEvent::Move:
case QEvent::Paint:
return false; // just for performance - they can occur really often
case QEvent::Show:
if (widget->isEnabled())
play(widget);
return false;
case QEvent::Hide:
_release(widget);
return false;
case QEvent::EnabledChange:
if (widget->isEnabled())
play(widget);
else
_release(widget);
return false;
default:
return false;
}
}
bool
QLuaApplication::event(QEvent *e)
{
if (e->type() == QEvent::FileOpen)
{
QString f = static_cast<QFileOpenEvent*>(e)->file();
d->filesToOpen.append(f);
emit fileOpenEvent();
return true;
}
else if (e->type() == QEvent::Close)
{
// carefully close all windows
bool okay = true;
QSet<QWidget*> closed;
QWidgetList wl = topLevelWidgets();
while (okay && wl.size())
{
QWidget *w = wl.takeFirst();
if (w == 0 || !w->isVisible() ||
w->windowType() == Qt::Desktop ||
closed.contains(w) )
continue;
closed += w;
okay = w->close();
wl = topLevelWidgets();
}
// accept event on success
e->setAccepted(okay);
return true;
}
return QApplication::event(e);
}
QString LayoutDumper::getWidgetInfo(const QWidget& w)
{
const QRect& geom = w.geometry();
QSize sizehint = w.sizeHint();
QSize minsizehint = w.minimumSizeHint();
// Can't have >9 arguments to QString arg() system.
// Using QStringBuilder with % leads to more type faff.
QStringList elements;
elements.append(QString("%1 %2 ('%3')")
.arg(w.metaObject()->className())
.arg(toString((void*)&w))
.arg(w.objectName()));
elements.append(QString("pos (%1, %2)")
.arg(geom.x())
.arg(geom.y()));
elements.append(QString("size (%1 x %2)")
.arg(geom.width())
.arg(geom.height()));
// elements.append(QString("minimumSize (%1 x %2)")
// .arg(w.minimumSize().width())
// .arg(w.minimumSize().height()));
// elements.append(QString("maximumSize (%1 x %2)")
// .arg(w.maximumSize().width())
// .arg(w.maximumSize().height()));
elements.append(QString("sizeHint (%1 x %2), minimumSizeHint (%3 x %4), policy %5")
.arg(sizehint.width())
.arg(sizehint.height())
.arg(minsizehint.width())
.arg(minsizehint.height())
.arg(toString(w.sizePolicy())));
elements.append(QString("stylesheet=%1")
.arg(w.styleSheet().isEmpty() ? "false" : "true"));
elements.append(w.isVisible() ? "visible" : "HIDDEN");
return elements.join(", ");
}
void MainWindowPlugin::onOptionsChanged(const OptionsNode &ANode)
{
QWidget * widget = FMainWindowBorder ? (QWidget*)FMainWindowBorder : (QWidget*)FMainWindow;
if (ANode.path() == OPV_MAINWINDOW_STAYONTOP)
{
bool show = widget->isVisible();
if (ANode.value().toBool())
widget->setWindowFlags(widget->windowFlags() | Qt::WindowStaysOnTopHint);
else
widget->setWindowFlags(widget->windowFlags() & ~Qt::WindowStaysOnTopHint);
if (show)
showMainWindow();
}
#ifdef Q_OS_WIN
else if (ANode.path() == OPV_MAINWINDOW_MINIMIZETOTRAY_W7)
{
if (QSysInfo::windowsVersion() == QSysInfo::WV_WINDOWS7)
{
bool minimize = ANode.value().toBool();
FMainWindowBorder->setMinimizeOnClose(!minimize);
FMainWindowBorder->setShowInTaskBar(!minimize);
if (minimize)
disconnect(FMainWindowBorder ? (QObject*)FMainWindowBorder : (QObject*)FMainWindow, SIGNAL(closed()), this, SLOT(onMainWindowClosed()));
else
connect(FMainWindowBorder ? (QObject*)FMainWindowBorder : (QObject*)FMainWindow, SIGNAL(closed()), SLOT(onMainWindowClosed()));
}
else
FMainWindowBorder->setShowInTaskBar(false);
}
#endif
}
void StatusBar::paintEvent(QPaintEvent*) {
QObjectList list = children(); //queryList( "QWidget", 0, false, false );
QPainter p(this);
//for( QObject * o = list.first(); o; o = list.next() ) {
foreach(QObject *o, list) {
if (o->inherits("QWidget")) {
QWidget *w = (QWidget*)o;
if (!w->isVisible()) {
continue;
}
/*style().drawPrimitive(
QStyle::PE_StatusBarSection,
&p,
QRect( w->x() - 1, w->y() - 1, w->width() + 2, w->height() + 2 ),
colorGroup(),
QStyle::State_None,
QStyleOption( w ) );*/
}
}
//delete list;
}
void FLDataTable::selectRow(int r, int c)
{
if (!cursor_ || !cursor_->metadata())
return ;
if (r < 0) {
if (cursor_->isValid()) {
rowSelected = cursor_->at();
colSelected = currentColumn();
} else {
rowSelected = 0;
colSelected = 0;
}
} else {
rowSelected = r;
colSelected = c;
}
QObject *snd = const_cast<QObject *>(sender());
if (!snd || (snd && !snd ->isA("FLSqlCursor"))) {
QWidget *sndw = ::qt_cast<QWidget *>(snd);
if (sndw) {
if (!sndw->hasFocus() || !sndw->isVisible()) {
setCurrentCell(rowSelected, colSelected);
return ;
}
}
if (numRows() != cursor_->size())
setNumRows(cursor_->size());
cursor_->seek(rowSelected);
}
setCurrentCell(rowSelected, colSelected);
}
void QWidgetPrivate::hide_sys()
{
Q_Q(QWidget);
QWindow *window = q->windowHandle();
if (q->testAttribute(Qt::WA_DontShowOnScreen)) {
q->setAttribute(Qt::WA_Mapped, false);
if (q->isWindow() && q->windowModality() != Qt::NonModal && window) {
// remove our window from the modal window list
QGuiApplicationPrivate::hideModalWindow(window);
}
// do not return here, if window non-zero, we must hide it
}
deactivateWidgetCleanup();
if (!q->isWindow()) {
QWidget *p = q->parentWidget();
if (p &&p->isVisible()) {
invalidateBuffer(q->rect());
}
} else {
invalidateBuffer(q->rect());
}
if (window)
window->setVisible(false);
}
void QWidget::setActiveWindow()
{
QWidget *tlw = topLevelWidget();
if ( tlw->isVisible() ) {
qwsDisplay()->requestFocus( tlw->winId(), TRUE);
}
}
void QWidget::hideWindow()
{
deactivateWidgetCleanup();
if (req_region.isEmpty()) // Already invisible?
return;
if ( testWFlags(WType_TopLevel) ) {
releaseMouse();
#ifndef QT_NO_QWS_MANAGER
if (QWSManager::grabbedMouse() == this) {
if ( extra && extra->topextra && extra->topextra->qwsManager ) {
extra->topextra->qwsManager->releaseGrab();
}
}
#endif
qwsDisplay()->requestRegion(winId(), QRegion());
qwsDisplay()->requestFocus(winId(),FALSE);
} else {
QWidget *p = parentWidget();
if ( p ) {
p->setChildrenAllocatedDirty( geometry(), this );
p->paintable_region_dirty = TRUE;
if ( p->overlapping_children )
p->overlapping_children = -1;
if ( p->isVisible() ) {
QApplication::postEvent( p, new QPaintEvent(geometry(), TRUE) );
paint_children( p,geometry(),TRUE );
}
}
}
updateRequestedRegion( mapToGlobal(QPoint(0,0)) );
}
void QWidget::updateOverlappingChildren() const
{
if ( overlapping_children != -1 || isSettingGeometry )
return;
QRegion r;
const QObjectList *c = children();
if ( c ) {
QObjectListIt it(*c);
QObject* ch;
while ((ch=it.current())) {
++it;
if ( ch->isWidgetType() && !((QWidget*)ch)->isTopLevel() ) {
QWidget *w = (QWidget *)ch;
if ( w->isVisible() ) {
QRegion rr( w->req_region );
QRegion ir = r & rr;
if ( !ir.isEmpty() ) {
overlapping_children = 1;
return;
}
r |= rr;
}
}
}
}
overlapping_children = 0;
}
/*! \reimp */
int QAccessibleWidget::childAt(int x, int y) const
{
QWidget *w = widget();
if (!w->isVisible())
return -1;
QPoint gp = w->mapToGlobal(QPoint(0, 0));
if (!QRect(gp.x(), gp.y(), w->width(), w->height()).contains(x, y))
return -1;
QWidgetList list = childWidgets(w);
int ccount = childCount();
// a complex child
if (list.size() < ccount) {
for (int i = 1; i <= ccount; ++i) {
if (rect(i).contains(x, y))
return i;
}
return 0;
}
QPoint rp = w->mapFromGlobal(QPoint(x, y));
for (int i = 0; i<list.size(); ++i) {
QWidget *child = list.at(i);
if (!child->isWindow() && !child->isHidden() && child->geometry().contains(rp)) {
return i + 1;
}
}
return 0;
}
void App::slotRefreshWindowMenu()
{
QWidget* widget;
int id = 0;
QPtrList <QWidget> wl = workspace()->windowList();
m_windowMenu->clear();
m_windowMenu->insertItem(QPixmap(QString(PIXMAPS) + QString("/view_sidetree.png")),
"Cascade", this, SLOT(slotWindowCascade()),
0, ID_WINDOW_CASCADE);
m_windowMenu->insertItem(QPixmap(QString(PIXMAPS) + QString("/view_left_right.png")),
"Tile", this, SLOT(slotWindowTile()),
0, ID_WINDOW_TILE);
m_windowMenu->insertSeparator();
for (widget = wl.first(); widget != NULL; widget = wl.next())
{
m_windowMenu->insertItem(widget->caption(), id);
if (widget->isVisible() == true)
{
m_windowMenu->setItemChecked(id, true);
}
id++;
}
connect(m_windowMenu, SIGNAL(activated(int)),
this, SLOT(slotWindowMenuCallback(int)));
}
bool TraceItemView::isViewVisible()
{
QWidget* w = widget();
if (w)
return w->isVisible();
return false;
}
QWidget* QtEventConsumer::isValidWidget(QObject *obj)
{
// check the object
if (!obj->isWidgetType()){
return NULL;
}
// check the widget
QWidget* w = dynamic_cast<QWidget*>(obj);
_d("W > " << QWidgetUtils::getWidgetPath(w).toStdString());
if (!w) {
DEBUG(D_CONSUMER,"(QtEventConsumer::isValidWidget) Widget is null");
DEBUG(D_CONSUMER,"(QtEventConsumer::isValidWidget) -> " + QWidgetUtils::getWidgetPath(w).toStdString());
return NULL;
}
else if (!w->isVisible()) {
DEBUG(D_CONSUMER,"(QtEventConsumer::isValidWidget) Widget is not visible");
DEBUG(D_CONSUMER,"(QtEventConsumer::isValidWidget) -> " + QWidgetUtils::getWidgetPath(w).toStdString());
return NULL;
}
else if (!w->isEnabled()) {
DEBUG(D_CONSUMER,"(QtEventConsumer::isValidWidget) Widget is not enabled");
DEBUG(D_CONSUMER,"(QtEventConsumer::isValidWidget) -> " + QWidgetUtils::getWidgetPath(w).toStdString());
return NULL;
}
_d("W > " << QWidgetUtils::getWidgetPath(w).toStdString());
_d("VALID WIDGET");
return w;
}
bool DockPlugin::isMainShow()
{
QWidget *main = getMainWindow();
if (main && main->isVisible())
return true;
return false;
}
void App::slotRefreshWindowMenu()
{
QWidget* widget;
int id = 0;
QList <QWidget> wl = workspace()->windowList();
QString dir;
settings()->get(KEY_SYSTEM_DIR, dir);
dir += QString("/") + PIXMAPPATH;
m_windowMenu->clear();
m_windowMenu->insertItem(QPixmap(dir + QString("/cascadewindow.xpm")), "Cascade", this, SLOT(slotWindowCascade()), 0, ID_WINDOW_CASCADE);
m_windowMenu->insertItem(QPixmap(dir + QString("/tilewindow.xpm")), "Tile", this, SLOT(slotWindowTile()), 0, ID_WINDOW_TILE);
m_windowMenu->insertSeparator();
for (widget = wl.first(); widget != NULL; widget = wl.next())
{
m_windowMenu->insertItem(widget->caption(), id);
if (widget->isVisible() == true)
{
m_windowMenu->setItemChecked(id, true);
}
id++;
}
connect(m_windowMenu, SIGNAL(activated(int)), this, SLOT(slotWindowMenuCallback(int)));
}
/* Handles closing all of the open editor windows when the window is closed */
void MainWindow::closeEvent(QCloseEvent *e)
{
int widgetCount = ui_tabWidget->count();
while(ui_tabWidget->count() > 0) {
ui_tabWidget->setCurrentIndex(0);
closeTab();
if(ui_tabWidget->count() == widgetCount) {
qWarning() << "Ignoring close event.";
e->ignore();
return;
}
--widgetCount;
}
//Close all other windows
hide();
QListIterator<QWidget *> i(qApp->topLevelWidgets());
while(i.hasNext()) {
QWidget *w = i.next();
if(w->isVisible())
w->close();
}
QMainWindow::closeEvent(e);
}
/*
* Broadcast event to all windows
*/
bool lamexp_broadcast(int eventType, bool onlyToVisible)
{
if(QApplication *app = dynamic_cast<QApplication*>(QApplication::instance()))
{
qDebug("Broadcasting %d", eventType);
bool allOk = true;
QEvent poEvent(static_cast<QEvent::Type>(eventType));
QWidgetList list = app->topLevelWidgets();
while(!list.isEmpty())
{
QWidget *widget = list.takeFirst();
if(!onlyToVisible || widget->isVisible())
{
if(!app->sendEvent(widget, &poEvent))
{
allOk = false;
}
}
}
qDebug("Broadcast %d done (%s)", eventType, (allOk ? "OK" : "Stopped"));
return allOk;
}
else
{
qWarning("Broadcast failed, could not get QApplication instance!");
return false;
}
}
void QWidgetPrivate::raise_sys()
{
Q_Q(QWidget);
//@@@ transaction
if (q->isWindow()) {
Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
QWidget::qwsDisplay()->setAltitude(q->internalWinId(),
QWSChangeAltitudeCommand::Raise);
// XXX: subsurfaces?
#ifdef QT_NO_WINDOWGROUPHINT
#else
QObjectList childObjects = q->children();
if (!childObjects.isEmpty()) {
QWidgetList toraise;
for (int i = 0; i < childObjects.size(); ++i) {
QObject *obj = childObjects.at(i);
if (obj->isWidgetType()) {
QWidget* w = static_cast<QWidget*>(obj);
if (w->isWindow())
toraise.append(w);
}
}
for (int i = 0; i < toraise.size(); ++i) {
QWidget *w = toraise.at(i);
if (w->isVisible())
w->raise();
}
}
#endif // QT_NO_WINDOWGROUPHINT
}
}
void WindowMenu::onAboutToShow()
{
QWidget* win = QApplication::activeWindow();
pMinimize_->setEnabled(win);
pZoom_->setEnabled(win && win->maximumSize() != win->minimumSize());
pBringAllToFront_->setEnabled(win);
for (int i = windows_.size() - 1; i >= 0; i--)
{
QAction* pAction = windows_[i];
removeAction(pAction);
windows_.removeAt(i);
pAction->deleteLater();
}
QWidgetList topLevels = QApplication::topLevelWidgets();
for (int i = 0; i < topLevels.size(); i++)
{
QWidget* pWindow = topLevels.at(i);
if (!pWindow->isVisible())
continue;
QAction* pAction = new QAction(pWindow->windowTitle(), pWindow);
pAction->setData(QVariant::fromValue(pWindow));
pAction->setCheckable(true);
if (pWindow->isActiveWindow())
pAction->setChecked(true);
insertAction(pWindowPlaceholder_, pAction);
connect(pAction, SIGNAL(triggered()),
this, SLOT(showWindow()));
windows_.append(pAction);
}
}
QWidgetList QAccessibleAbstractScrollArea::accessibleChildren() const
{
QWidgetList children;
// Viewport.
QWidget * viewport = abstractScrollArea()->viewport();
if (viewport)
children.append(viewport);
// Horizontal scrollBar container.
QScrollBar *horizontalScrollBar = abstractScrollArea()->horizontalScrollBar();
if (horizontalScrollBar && horizontalScrollBar->isVisible()) {
children.append(horizontalScrollBar->parentWidget());
}
// Vertical scrollBar container.
QScrollBar *verticalScrollBar = abstractScrollArea()->verticalScrollBar();
if (verticalScrollBar && verticalScrollBar->isVisible()) {
children.append(verticalScrollBar->parentWidget());
}
// CornerWidget.
QWidget *cornerWidget = abstractScrollArea()->cornerWidget();
if (cornerWidget && cornerWidget->isVisible())
children.append(cornerWidget);
return children;
}
/*
Internal function called from QWidget::setCursor()
force is true if this function is called from dispatchEnterLeave, it means that the
mouse is actually directly under this widget.
*/
void qt_symbian_set_cursor(QWidget *w, bool force)
{
static QPointer<QWidget> lastUnderMouse = 0;
if (force) {
lastUnderMouse = w;
}
else if (w->testAttribute(Qt::WA_WState_Created) && lastUnderMouse
&& lastUnderMouse->effectiveWinId() == w->effectiveWinId()) {
w = lastUnderMouse;
}
if (!S60->curWin && w && w->internalWinId())
return;
QWidget* cW = w && !w->internalWinId() ? w : QWidget::find(S60->curWin);
if (!cW || cW->window() != w->window() || !cW->isVisible() || !cW->underMouse()
|| QApplication::overrideCursor())
return;
#ifndef Q_SYMBIAN_FIXED_POINTER_CURSORS
if (S60->brokenPointerCursors)
qt_symbian_set_pointer_sprite(cW->cursor());
else
#endif
qt_symbian_setWindowCursor(cW->cursor(), w->effectiveWinId());
}
void QWidget::activateWindow()
{
QWidget *tlw = window();
if (tlw->isVisible()) {
Q_ASSERT(tlw->testAttribute(Qt::WA_WState_Created));
qwsDisplay()->requestFocus(tlw->internalWinId(), true);
}
}
bool VideoWidget::isWidgetVisible()
{
QWidget* widget = dynamic_cast<QWidget*>(this);
if(widget->isVisible())
return true;
else
return false;
}
void VideoWidget::toogleVisibility()
{
QWidget* widget = dynamic_cast<QWidget*>(this);
if(widget->isVisible())
widget->hide();
else
widget->show();
}
