void EmergencyWindowManager::positionCornerWindows()
{
    if (Settings::LunaSettings()->tabletUi)
        return;

    int i = kTopLeftWindowIndex;
    int trueBottom = m_winRect.y() + m_winRect.height();
    int trueRight = m_winRect.x() + m_winRect.width();
    Q_ASSERT(m_corners[i]);
    QRectF rect = m_corners[i]->boundingRect();

    setPosTopLeft(m_corners[i], m_winRect.x(), m_winRect.y());

    i = kTopRightWindowIndex;
    Q_ASSERT(m_corners[i]);
    setPosTopLeft(m_corners[i], trueRight - rect.width(), m_winRect.y());

    i = kBottomLeftWindowIndex;
    Q_ASSERT(m_corners[i]);
    setPosTopLeft(m_corners[i], m_winRect.x(), trueBottom - rect.height());

    i = kBottomRightWindowIndex;
    Q_ASSERT(m_corners[i]);
    setPosTopLeft(m_corners[i], trueRight - rect.width(), trueBottom - rect.height());
}
Beispiel #2
0
void MenuWindowManager::slotPositiveSpaceChanged(const QRect& r)
{
	m_positiveSpace = r;
	
	positionCornerWindows(r);

	Q_FOREACH(Window* w, m_winArray) {
		if (w)
			setPosTopLeft(w, r.x(), r.y());
	}

	if (m_statusBar) {
		setPosTopLeft(m_statusBar, 0, r.y() - m_statusBar->boundingRect().height());
	}
	update();
}
void InputWindowManager::slotNegativeSpaceChanged(QRect r)
{
	if (!m_activeIME)
		return;

	qreal y = m_activeIME->m_keyboardHeight.get() - r.height();
	m_imeView->setVisible(r.height() != 0);
	setPosTopLeft(m_imeView, 0, y);
}
Beispiel #4
0
void MenuWindowManager::positionCornerWindows(const QRect& r)
{
	if(!Settings::LunaSettings()->tabletUi) {
		int i = kTopLeftWindowIndex;
		int trueBottom = r.y() + r.height();
		int trueRight = r.x() + r.width();
		QRectF rect = m_corners[i]->boundingRect();

		setPosTopLeft(m_corners[i], r.x(), r.y());
	
		i = kTopRightWindowIndex;
		setPosTopLeft(m_corners[i], trueRight - rect.width(), r.y());

		i = kBottomLeftWindowIndex;
		setPosTopLeft(m_corners[i], r.x(), trueBottom - rect.height());
	
		i = kBottomRightWindowIndex;
		setPosTopLeft(m_corners[i], trueRight - rect.width(), trueBottom - rect.height());
	}
}
void EmergencyWindowManager::addWindow(Window* win)
{
	if (win->type() != Window::Type_Emergency)
		return;

	if (m_emergencyWindow) {

		luna_critical(s_logChannel, "Only one emergency window is allowed at a time");
		WebAppMgrProxy::instance()->closeWindow(win);
		return;
	}
	setVisible(true);
	
	m_emergencyWindow = win;
	static_cast<CardWindow*>(win)->focusEvent(true);
	IMEController::instance()->setClient(static_cast<HostWindow*>(win));

	m_emergencyWindow->setParentItem(this);
	m_emergencyWindow->stackBefore(m_cornerContainer);
	m_emergencyWindow->setOpacity(kFadedOpacity);
	m_emergencyWindow->setVisible(true);
	static_cast<CardWindow*>(m_emergencyWindow)->setPaintCompositionMode(QPainter::CompositionMode_SourceOver);

	static_cast<CardWindow*>(m_emergencyWindow)->setBoundingRect(m_winRect.width(), m_winRect.height());

	setPosTopLeft(win, m_winRect.x(), m_winRect.y());

	positionCornerWindows();
	showCornerWindows();

	SystemUiController::instance()->setEmergencyMode(true);

	if (static_cast<CardWindow*>(m_emergencyWindow)->fullScreen())
		SystemUiController::instance()->hideStatusBarAndNotificationArea();
	else {
		SystemUiController::instance()->showStatusBarAndNotificationArea();
	}
	
	m_opacityAnimPtr = new QPropertyAnimation();
	m_opacityAnimPtr->setPropertyName("opacity");
	m_opacityAnimPtr->setEasingCurve(QEasingCurve::Linear);
	m_opacityAnimPtr->setTargetObject(m_emergencyWindow);
	m_opacityAnimPtr->setDuration(kFadeAnimDuration);
	m_opacityAnimPtr->setEndValue(1.0);
	connect(m_opacityAnimPtr, SIGNAL(finished()), SLOT(fadeAnimationFinished()));
	m_opacityAnimPtr->start(QAbstractAnimation::DeleteWhenStopped);
	
	update();
}
Beispiel #6
0
void MenuWindowManager::showMenuWindow(Window* win)
{
	if (!m_winArray.contains(win))
		m_winArray.append(win);

	PersistentWindowCache* persistCache = PersistentWindowCache::instance();
	if (persistCache->shouldPersistWindow(win)) {

		if (!persistCache->hasWindow(win))
			persistCache->addWindow(win);

		persistCache->showWindow(win);
	}

	raiseWindow(win);
	
	setPosTopLeft(win, m_positiveSpace.x(), m_positiveSpace.y());
	SystemUiController::instance()->setMenuVisible(true);

	update(m_positiveSpace);
}
void EmergencyWindowManager::slotPositiveSpaceChanged(const QRect& r)
{
	// The emergency window manager always covers the whole display but limits 
	// the size of the active emergency window to be either full screen or
	// screen height - top positive space

	int positiveSpaceTopPadding = Settings::LunaSettings()->positiveSpaceTopPadding;

	int y = qMin(r.y(), positiveSpaceTopPadding);
	int w = SystemUiController::instance()->currentUiWidth() - r.x();
	int h = SystemUiController::instance()->currentUiHeight() - y;

	m_winRect.setX(qMin(0, r.x()));
	m_winRect.setY(y);
	m_winRect.setHeight(h);
	m_winRect.setWidth(w);

	positionCornerWindows();

	if (m_emergencyWindow) {
		setPosTopLeft(m_emergencyWindow, m_winRect.x(), m_winRect.y());
		static_cast<CardWindow*>(m_emergencyWindow)->resizeEvent(w, h);
	}
}