void toToolWidget::importData(std::map<QString, QString> &data, const QString &prefix)
{
QWidget *par = parentWidget();
if (!par)
par = this;
if (data[prefix + ":State"] == QString::fromLatin1("Maximized"))
{
par->showMaximized();
showMaximized();
}
else if (data[prefix + ":State"] == QString::fromLatin1("Minimized"))
{
par->showMinimized();
showMinimized();
}
else
{
par->showNormal();
par->setGeometry(data[prefix + ":X"].toInt(),
data[prefix + ":Y"].toInt(),
data[prefix + ":Width"].toInt(),
data[prefix + ":Height"].toInt());
}
}
//===========================================================================
void DiffAnalystWindow::onCascade()
{
// from QWorkspace.cpp
const int xoffset = 13;
const int yoffset = 23;
const int width = 640;
const int height = 480;
int x = 0;
int y = 0;
m_pWs->cascade ();
int numWnd = m_pWs->windowList ().count ();
for (int i = 0; i < numWnd; ++i)
{
QWidget *pWnd = m_pWs->windowList ().at (i);
if (!pWnd->isHidden ())
{
pWnd->showNormal ();
pWnd->parentWidget ()->setGeometry (x, y, width, height);
if ((y + yoffset + height) <= m_pWs->height ())
{
x += xoffset;
y += yoffset;
}
else
{
x = 0;
y = 0;
}
}
}
}
void bringToFront(QWidget *widget, bool)
{
Q_ASSERT(widget);
QWidget* w = widget->window();
#ifdef Q_WS_X11
// If we're not on the current desktop, do the hide/show trick
long dsk, curr_dsk;
Window win = w->winId();
if(desktopOfWindow(&win, &dsk) && currentDesktop(&curr_dsk)) {
if((dsk != curr_dsk) && (dsk != -1)) { // second condition for sticky windows
w->hide();
}
}
// FIXME: multi-desktop hacks for Win and Mac required
#endif
if(w->isMaximized())
w->showMaximized();
else
w->showNormal();
//if(grabFocus)
// w->setActiveWindow();
w->raise();
w->activateWindow();
#ifdef Q_WS_WIN
// TODO: unify with AdvancedWidget::bringToFront()
ForceForegroundWindow(w->winId());
#endif
}
void QtApplication::toggleFullscreen()
{
QWidget *p = toplevelWidget();
if(p->isFullScreen())
{ p->showNormal(); }
else
{ p->showFullScreen(); }
}
void ApplicationWindow::windowsMenuActivated( int id )
{
QWidget* w = ws->windowList().at( id );
if ( w ) {
w->showNormal();
w->setFocus();
}
}
void Nexus::toggleFullscreen()
{
QWidget* window = QApplication::activeWindow();
if (window->isFullScreen())
window->showNormal();
else
window->showFullScreen();
}
void VideoOutputEventFilter::switchFullScreen()
{
if (!mpRenderer || !mpRenderer->widget())
return;
QWidget *window = mpRenderer->widget()->window();
if (window->isFullScreen())
window->showNormal();
else
window->showFullScreen();
}
/*
This slot is responsible for showing an activated window via the Window menu
*/
void CMDIWindow::windowActivated(int id)
{
#ifdef DEBUG
qDebug("CMDIWindow::windowActivated()");
#endif
QWidget* wnd = myApp()->workSpace()->windowList().at(id);
if (wnd)
wnd->showNormal();
wnd->setFocus();
}
void wxTopLevelWindowQt::Maximize(bool maximize)
{
QWidget *widget = GetHandle();
if ( maximize )
{
widget->showMaximized();
}
else
{
widget->showNormal();
}
}
void wxTopLevelWindowQt::Iconize(bool iconize )
{
QWidget *widget = GetHandle();
if ( iconize )
{
widget->showMinimized();
}
else
{
widget->showNormal();
}
}
bool TaskbarPreviews::WasTabActivated(HWND hwnd)
{
QWidget *internal = m_tabs.internal(hwnd);
if (internal) {
QWidget *owner = m_tabs.owner(hwnd);
SetTabActive((HWND)internal->winId(), (HWND)owner->winId());
if (owner->isMinimized())
owner->showNormal();
qApp->setActiveWindow(owner);
emit tabActivated(m_tabs.user(hwnd));
return true;
} else
return false;
}
bool wxTopLevelWindowQt::ShowFullScreen(bool show, long WXUNUSED(style))
{
QWidget *widget = GetHandle();
if ( show )
{
widget->showFullScreen();
}
else
{
widget->showNormal();
}
return true;
}
bool VideoOutputEventFilter::eventFilter(QObject *watched, QEvent *event)
{
// a widget shown means it's available and not deleted
if (event->type() == QEvent::Show || event->type() == QEvent::ShowToParent) {
mRendererIsQObj = !!mpRenderer->widget();
return false;
}
if (!mRendererIsQObj)
return false;
/*
* deleted renderer (after destroyed()) can not access it's member, so we must mark it as invalid.
* hide event is sent when close. what about QEvent::Close?
*/
if (event->type() == QEvent::Close || event->type() == QEvent::Hide) {
mRendererIsQObj = false;
return true;
}
if (!mpRenderer)
return false;
if (watched != mpRenderer->widget()
/* && watched != mpRenderer->graphicsWidget()*/ //no showFullScreen() etc.
)
return false;
switch (event->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_F: { //TODO: move to gui
//TODO: active window
QWidget *w = mpRenderer->widget();
if (!w)
return false;
if (w->isFullScreen())
w->showNormal();
else
w->showFullScreen();
}
break;
}
}
break;
default:
break;
}
return false;
}
// Convert a tab to an external window
void MHTabWidget::DetachTab(int index, QPoint & dropPoint)
{
Q_UNUSED(dropPoint);
// Create the window
MHDetachedWindow* detachedWidget = new MHDetachedWindow(parentWidget(), this);
detachedWidget->setWindowModality(Qt::NonModal);
// Find Widget and connect
connect(detachedWidget, SIGNAL(OnClose(QWidget*)), this, SLOT(AttachTab(QWidget*)));
detachedWidget->setWindowTitle(tabText(index));
detachedWidget->setWindowIcon(tabIcon(index));
// Remove from tab bar
QWidget* tearOffWidget = widget(index);
tearOffWidget->setParent(detachedWidget);
// Add it to the windows list
m_Windows.append(tearOffWidget);
// Make first active
if(count() > 0)
setCurrentIndex(0);
// Create and show
detachedWidget->setCentralWidget(tearOffWidget);
// Needs to be done explicitly
tearOffWidget->showNormal();
QRect screenGeometry = QApplication::desktop()->screenGeometry();
int w = 640;
int h = 480;
int x = (screenGeometry.width() - w) / 2;
int y = (screenGeometry.height() - h) / 2;
detachedWidget->showNormal();
detachedWidget->setGeometry(x, y, w, h);
detachedWidget->showNormal();
}
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
}
/* FUNCTION: showWindow */
void TrajectoryGraphicsTreeItem::showWindow()
{
QWidget *activeWidget = resultsWindow->workspace->activeWindow();
bool activeWidgetIsMaximized =
(activeWidget != 0) && (activeWidget->isMaximized());
if(activeWidgetIsMaximized)
activeWidget->showNormal();
if (trajWindow == NULL) {
NXEntityManager* entityManager = resultsWindow->entityManager;
NXDataStoreInfo* dataStoreInfo = entityManager->getDataStoreInfo();
NXGraphicsManager* graphicsManager = resultsWindow->graphicsManager;
int trajId = dataStoreInfo->getTrajectoryId(trajectoryName);
trajWindow =
new TrajectoryGraphicsWindow((QWidget*)0,
entityManager,
graphicsManager);
/// @fixme Trap errors
resultsWindow->workspace->addWindow(trajWindow);
trajWindow->resize((resultsWindow->workspace->size()) *= 0.75);
trajWindow->setWindowTitle(QString(trajectoryName.c_str()));
resultsWindow->workspace->setActiveWindow(trajWindow);
trajWindow->show();
trajWindow->setFrameSetId(trajId);
// set initial view
if(dataStoreInfo->hasLastView()) {
NXNamedView const& lastView = dataStoreInfo->getLastView();
trajWindow->setNamedView(lastView);
NXLOG_DEBUG("TrajectoryGraphicsWindow", "Setting NE1 last-view");
}
else if(dataStoreInfo->hasHomeView()) {
NXNamedView const& homeView = dataStoreInfo->getHomeView();
trajWindow->setNamedView(homeView);
NXLOG_DEBUG("TrajectoryGraphicsWindow", "Setting NE1 home-view");
}
else {
trajWindow->resetView();
NXLOG_DEBUG("TrajectoryGraphicsWindow",
"Inferring default view from atom layout");
}
if (!dataStoreInfo->storeIsComplete(trajId)) {
QObject::connect(entityManager,
SIGNAL(newFrameAdded(int, int, NXMoleculeSet*)),
trajWindow,
SLOT(newFrame(int, int, NXMoleculeSet*)));
}
// resultsWindow->workspace->update();
}
// else
// trajWindow->show();
if(activeWidgetIsMaximized)
trajWindow->showMaximized();
else
trajWindow->showNormal();
}
/**
\return
**/
void BfCompany::cargaConf()
{
BL_FUNC_DEBUG
QFile file ( g_confpr->value( CONF_DIR_USER ) + "bulmafact_" + dbName() + ".cfn" );
QDomDocument doc ( "mydocument" );
if ( !file.open ( QIODevice::ReadOnly ) )
return;
if ( !doc.setContent ( &file ) ) {
file.close();
return;
}
file.close();
// print out the element names of all elements that are direct children
// of the outermost element.
QDomElement docElem = doc.documentElement();
QDomElement principal = docElem.firstChildElement ( "PRINCIPAL" );
/// Cogemos la coordenada X
QString nx = principal.firstChildElement ( "X" ).toElement().text();
/// Cogemos la coordenada Y
QString ny = principal.firstChildElement ( "Y" ).toElement().text();
/// Cogemos el ancho
QString nwidth = principal.firstChildElement ( "WIDTH" ).toElement().text();
/// Cogemos el alto
QString nheight = principal.firstChildElement ( "HEIGHT" ).toElement().text();
/// Si está maximizada, ignoramos las otras dimensiones
if (principal.firstChildElement ( "MAXIMIZED" ).toElement().text() == "true")
m_bulmafact->setWindowState(Qt::WindowMaximized);
else /// Establecemos la geometria de la ventana principal.
m_bulmafact->setGeometry ( nx.toInt(), ny.toInt(), nwidth.toInt(), nheight.toInt() );
/// Cogemos el indexador
QString indexador = principal.firstChildElement ( "INDEXADOR" ).toElement().text();
if ( indexador == "true" ) {
s_indexadorCambiaEstado ( true );
m_bulmafact->actionIndexador->setChecked ( true );
} else {
s_indexadorCambiaEstado ( false );
m_bulmafact->actionIndexador->setChecked ( false );
} // end if
/// Cogemos el ancho del indexador
m_bulmafact->restoreState ( QByteArray::fromBase64 ( QByteArray ( principal.firstChildElement ( "TOOLBARSDOCKWIDGETS" ).toElement().text().toLatin1() ) ) );
/// Tratamos cada ventana
QWidget *activewindow = NULL;
QDomNodeList nodos = docElem.elementsByTagName ( "VENTANA" );
for ( int i = 0; i < nodos.count(); i++ ) {
QDomNode ventana = nodos.item ( i );
QDomElement e1 = ventana.toElement(); /// try to convert the node to an element.
if ( !e1.isNull() ) { /// the node was really an element.
QString vname = e1.firstChildElement ( "VNAME" ).toElement().text();
for ( int j = 0; j < m_windowListDock->numVentanas(); j++ ) {
QObject *obj = m_windowListDock->ventana ( j );
QWidget *wid = ( QWidget * ) obj;
if ( obj->objectName() == vname ) {
QString vx = e1.firstChildElement ( "VX" ).toElement().text();
QString vy = e1.firstChildElement ( "VY" ).toElement().text();
QString vwidth = e1.firstChildElement ( "VWIDTH" ).toElement().text();
QString vheight = e1.firstChildElement ( "VHEIGHT" ).toElement().text();
QString vvisible = e1.firstChildElement ( "VVISIBLE" ).toElement().text();
QString vmaximized = e1.firstChildElement ( "VMAXIMIZED" ).toElement().text();
QString vactivewindow = e1.firstChildElement ( "VACTIVEWINDOW" ).toElement().text();
/// Establecemos la geometria de la ventana principal.
wid->resize ( vwidth.toInt(), vheight.toInt() );
wid->parentWidget() ->move ( vx.toInt(), vy.toInt() );
if ( vvisible == "true" ) {
wid->showNormal();
} // end if
if ( vmaximized == "true" ) {
wid->showMaximized();
}
if ( vactivewindow == "true" ) {
activewindow = wid;
}
} // end if
} // end for
} // end if
} // end for
/// Si hay una ventana activa se pone como activa.
if ( activewindow )
activewindow->activateWindow();
}
void MainView::keyPressEvent(QKeyEvent *event)
{
if ( (event->modifiers() & Qt::ControlModifier || event->modifiers() & Qt::ShiftModifier)
&& event->key() == Qt::Key_Print)
{
event->accept();
QPrinter printer;
printer.setOutputFormat(QPrinter::PdfFormat);
printer.setFullPage(true);
printer.setResolution(300);
QSvgGenerator svggen;
svggen.setResolution(90);
if (event->modifiers() & Qt::ShiftModifier)
{
// Print scene
printer.setOutputFileName("screenshot-scene.pdf");
printer.setPaperSize(scene()->sceneRect().size().toSize(), QPrinter::Point);
QPainter painter(&printer);
painter.setRenderHint(QPainter::Antialiasing);
scene()->render( &painter );
svggen.setFileName("screenshot-scene.svg");
svggen.setSize(scene()->sceneRect().size().toSize());
QPainter svgPainter(&svggen);
svgPainter.setRenderHint(QPainter::Antialiasing);
scene()->render(&svgPainter);
QImage image(2 * scene()->sceneRect().size().toSize(), QImage::Format_ARGB32);
image.fill(Qt::transparent);
QPainter pmapPainter(&image);
pmapPainter.setRenderHint(QPainter::Antialiasing);
//pmapPainter.scale(2,2);
scene()->render(&pmapPainter);
image.save("screenshot-scene.png");
}
else
{
// Print view
printer.setOutputFileName("screenshot-view.pdf");
printer.setPaperSize(viewport()->rect().size(), QPrinter::Point);
QPainter painter(&printer);
painter.setRenderHint(QPainter::Antialiasing);
render(&painter);
svggen.setFileName("screenshot-view.svg");
svggen.setSize(viewport()->rect().size());
QPainter svgPainter(&svggen);
svgPainter.setRenderHint(QPainter::Antialiasing);
render(&svgPainter);
QImage image(2 * viewport()->rect().size(), QImage::Format_ARGB32);
image.fill(Qt::transparent);
QPainter pmapPainter(&image);
pmapPainter.setRenderHint(QPainter::Antialiasing);
render(&pmapPainter);
image.save("screenshot-view.png");
}
}
else if (event->modifiers() == Qt::NoModifier && event->key() == Qt::Key_F11)
{
event->accept();
QWidget* window = this;
while (window->parentWidget()) window = window->parentWidget();
if (window->isFullScreen()) window->showNormal();
else window->showFullScreen();
}
else if (event->modifiers() == Qt::NoModifier && event->key() == Qt::Key_F10)
{
event->accept();
if (miniMap->width() == MINIMAP_DEFAULT_WIDTH && miniMap->height() == MINIMAP_DEFAULT_HEIGHT)
setMiniMapSize(width(), height());
else setMiniMapSize(MINIMAP_DEFAULT_WIDTH, MINIMAP_DEFAULT_HEIGHT);
}
else if (event->modifiers() == Qt::NoModifier && event->key() == Qt::Key_F9)
{
event->accept();
if (miniMap->isVisible()) miniMap->hide();
else miniMap->show();
}
else if (event->modifiers() == Qt::NoModifier && event->key() == Qt::Key_F7)
{
event->accept();
showTimers_ = ~showTimers_;
updateInfoLabels();
}
else View::keyPressEvent(event);
}
bool EventFilter::eventFilter(QObject *watched, QEvent *event)
{
//qDebug("EventFilter::eventFilter to %p", watched);
Q_UNUSED(watched);
/*if (watched == reinterpret_cast<QObject*>(player->renderer)) {
qDebug("Event target is renderer: %s", watched->objectName().toAscii().constData());
}*/
//TODO: if not send to QWidget based class, return false; instanceOf()?
QEvent::Type type = event->type();
switch (type) {
case QEvent::MouseButtonPress:
qDebug("EventFilter: Mouse press");
static_cast<QMouseEvent*>(event)->button();
//TODO: wheel to control volume etc.
return false;
break;
case QEvent::KeyPress: {
//qDebug("Event target = %p %p", watched, player->renderer);
//avoid receive an event multiple times
int key = static_cast<QKeyEvent*>(event)->key();
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_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:
if (player->audio) {
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:
if (player->audio) {
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: {
//TODO: emit a signal so we can use custome dialogs
QString file = QFileDialog::getOpenFileName(0, tr("Open a video"));
if (!file.isEmpty())
player->play(file);
}
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_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;
default:
return false;
}
break;
}
default:
return false;
}
return true; //false: for text input
}
