void ZLWin32ApplicationWindow::refresh() {
ZLDesktopApplicationWindow::refresh();
if (!isFullscreen()) {
myToolbarInfo.cxIdeal = 0;
}
}
void ZLWin32ApplicationWindow::runPopup(const NMTOOLBAR &nmToolbar) {
Toolbar &tb = toolbar(isFullscreen() ? FULLSCREEN_TOOLBAR : WINDOW_TOOLBAR);
if (tb.hwnd == 0) {
return;
}
ZLToolbar::ItemPtr item = tb.TBItemByActionCode[nmToolbar.iItem];
if (!item.isNull()) {
const ZLToolbar::MenuButtonItem &button =
(const ZLToolbar::MenuButtonItem&)*item;
shared_ptr<ZLPopupData> popupData = button.popupData();
if (!popupData.isNull()) {
const int count = popupData->count();
if (count != 0) {
myPopupMenu = new ZLWin32PopupMenu(myMainWindow);
for (int i = 0; i < count; ++i) {
myPopupMenu->addItem(popupData->text(i), 0, true);
}
POINT p;
p.x = nmToolbar.rcButton.left;
p.y = nmToolbar.rcButton.bottom + 6;
ClientToScreen(myMainWindow, &p);
int code = myPopupMenu->run(p);
if (code > 0) {
popupData->run(code - 1);
}
myPopupMenu.reset();
}
}
}
}
bool BasisManager::keyPressed( const OIS::KeyEvent &arg )
{
// меняем оконный режим по Alt+Enter
if (arg.key == OIS::KC_RETURN) {
if (mInput->isKeyDown(OIS::KC_RMENU)) {
setFullscreen(!isFullscreen());
return true;
}
}
if ( arg.key == OIS::KC_SYSRQ ) {
std::ifstream stream;
std::string file;
do {
stream.close();
static size_t num = 0;
const size_t max_shot = 100;
if (num == max_shot) {
MYGUI_LOG(Info, "The limit of screenshots is exceeded : " << max_shot);
return true;
}
file = MyGUI::utility::toString("screenshot_", ++num, ".png");
stream.open(file.c_str());
} while (stream.is_open());
mWindow->writeContentsToFile(file);
return true;
}
return mStates.back()->keyPressed(arg);
}
/**
* Updates the checkbox when the view settings were changed.
*/
void View::updateFullscreen()
{
auto settings = ::FourInALine::getInstance()->getSettings();
auto viewSettings = settings->getViewSettings();
bool isFullscreen = viewSettings->isFullscreen();
this->fullscreenCheckboxAction->setChecked(isFullscreen);
}
void ZLEwlApplicationWindow::setFullscreen(bool fullscreen) {
if (fullscreen == isFullscreen()) {
return;
}
if (fullscreen) {
} else {
}
}
void Chimera_X11::setFullscreen( bool fs )
{
if( m_quickViewPtr && m_pluginWindow ) {
if( fs && !isFullscreen() ) {
m_quickViewPtr->hide();
m_quickViewPtr->setParent( 0 );
m_quickViewPtr->showFullScreen();
Q_EMIT fullscreenChanged( true );
} else if( !fs && isFullscreen() ) {
m_quickViewPtr->showNormal();
m_quickViewPtr->hide();
m_quickViewPtr->setParent( m_pluginWindow.data() );
onWindowResized( 0, static_cast<FB::PluginWindowX11*>( GetWindow() ) );
m_quickViewPtr->requestActivate();
Q_EMIT fullscreenChanged( false );
}
}
}
void FullscreenController::updateSize()
{
if (!isFullscreen())
return;
RenderFullScreen* renderer = Fullscreen::from(*m_fullScreenFrame->document()).fullScreenRenderer();
if (renderer)
renderer->updateStyle();
}
void WindowGL33::setFullscreen(bool fullscreen)
{
if (isFullscreen() && !fullscreen)
{
this->setPos(m_windowedX, m_windowedY);
this->setSize(m_windowedWidth, m_windowedHeight);
}
else if (!isFullscreen() && fullscreen)
{
m_windowedWidth = getFrameWidth();
m_windowedHeight = getFrameHeight();
m_windowedX = getX();
m_windowedY = getY();
this->setPos(0, 0);
this->setSize(m_fullscreenWidth, m_fullscreenHeight);
}
m_isFullscreen = fullscreen;
}
void Window::forceFullscreenMode()
{
if (!isFullscreen())
{
makeFullscreen();
SDL_SetWindowSize(window, dimensions.w, dimensions.h);
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN);
}
}
void FullscreenController::updateSize()
{
if (!isFullscreen())
return;
updatePageScaleConstraints(false);
LayoutFullScreen* layoutObject = Fullscreen::from(*m_fullScreenFrame->document()).fullScreenLayoutObject();
if (layoutObject)
layoutObject->updateStyle();
}
void Window::create()
{
if (isFullscreen() && !mVideoMode.isValid())
{
mVideoMode = sf::VideoMode::getFullscreenModes()[0];
}
sf::RenderWindow::create(mVideoMode,mTitle,mStyle);
setMouseCursor(mCursor);
updateBackground();
mVisible = true;
}
void Window::forceFullscreenMode(int w, int h)
{
if (!isFullscreen())
{
fullscreen = true;
setSize(w, h);
SDL_SetWindowPosition(window, 0, 0);
SDL_SetWindowSize(window, w, h);
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN);
}
}
void Window::forceWindowedMode()
{
if (isFullscreen())
{
fullscreen = false;
setSize(1280, 720);
SDL_SetWindowSize(window, 1280, 720);
SDL_SetWindowFullscreen(window, NULL);
SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
}
}
void Window::save(std::string const& filename)
{
pugi::xml_document doc;
doc.load_file(filename.c_str());
if (doc.child("Window"))
{
doc.remove_child("Window");
}
pugi::xml_node window = doc.append_child("Window");
window.append_child("VerticalSync").append_attribute("value") = mVerticalSync;
window.append_child("Fullscreen").append_attribute("value") = isFullscreen();
window.append_child("Resolution").append_attribute("value") = std::string(std::to_string(mVideoMode.width) + "," + std::to_string(mVideoMode.height)).c_str();
doc.save_file(filename.c_str());
}
/**
* Create all actions and connect them.
*/
void View::createActions()
{
auto settings = ::FourInALine::getInstance()->getSettings();
auto viewSettings = settings->getViewSettings();
QIcon fullscreenCheckboxIcon;
fullscreenCheckboxIcon.addFile(":/icons/fatcow/16x16/monitor.png", QSize(16, 16));
fullscreenCheckboxIcon.addFile(":/icons/fatcow/32x32/monitor.png", QSize(32, 32));
this->fullscreenCheckboxAction = new QAction(fullscreenCheckboxIcon, "", this);
this->fullscreenCheckboxAction->setCheckable(true);
this->fullscreenCheckboxAction->setChecked(viewSettings->isFullscreen());
this->connect(this->fullscreenCheckboxAction, &QAction::triggered, this, &View::changeFullscreen);
}
bool Chimera_X11::onWindowResized( FB::ResizedEvent*, FB::PluginWindowX11* w )
{
const int newWidth = w->getWindowWidth();
const int newHeight = w->getWindowHeight();
if( m_quickViewPtr && !isFullscreen() ) {
if( newWidth > 0 && newHeight > 0 ) {
if( !m_quickViewPtr->isVisible() )
m_quickViewPtr->show();
m_quickViewPtr->setX( 0 ); m_quickViewPtr->setY( 0 );
m_quickViewPtr->resize( newWidth, newHeight );
} else
m_quickViewPtr->hide();
}
return false;
}
void ZLWin32ApplicationWindow::setTooltip(TOOLTIPTEXT &tooltip) {
Toolbar &tb = toolbar(isFullscreen() ? FULLSCREEN_TOOLBAR : WINDOW_TOOLBAR);
if (tb.hwnd == 0) {
return;
}
ZLToolbar::ItemPtr item = tb.TBItemByActionCode[tooltip.hdr.idFrom];
if (!item.isNull()) {
const ZLToolbar::AbstractButtonItem &button =
(const ZLToolbar::AbstractButtonItem&)*item;
ZLUnicodeUtil::Ucs2String tooltipBuffer;
::createNTWCHARString(tooltipBuffer, button.tooltip());
size_t length = std::max(tooltipBuffer.size(), (size_t)80);
memcpy((char*)tooltip.szText, (char*)::wchar(tooltipBuffer), 2 * length);
tooltip.uFlags = TTF_DI_SETITEM;
}
}
ZLQtApplicationWindow::~ZLQtApplicationWindow() {
if (isFullscreen()) {
myWindowStateOption.setValue(FULLSCREEN);
} else if (isMaximized()) {
myWindowStateOption.setValue(MAXIMIZED);
} else {
myWindowStateOption.setValue(NORMAL);
if (x() != -1) {
myXOption.setValue(x());
}
if (y() != -1) {
myYOption.setValue(y());
}
myWidthOption.setValue(width());
myHeightOption.setValue(height());
}
}
bool NaClApplication::setFullscreen(bool enabled) {
/* Given fullscreen mode already set or switching to it is in progress, done */
if(isFullscreen() == enabled || ((_flags & Flag::FullscreenSwitchInProgress) && (_flags & Flag::WillBeFullscreen) == enabled))
return true;
/* Switch to opposite fullscreen mode is in progress, can't revert it back */
if((_flags & Flag::FullscreenSwitchInProgress) && (_flags & Flag::WillBeFullscreen) != enabled)
return false;
/* Set fullscreen */
if(!_fullscreen->SetFullscreen(enabled))
return false;
/* Set flags */
_flags |= Flag::FullscreenSwitchInProgress;
enabled ? _flags |= Flag::WillBeFullscreen : _flags &= ~Flag::WillBeFullscreen;
return true;
}
void ZLWin32ApplicationWindow::onToolbarButtonRelease(int actionCode) {
Toolbar &tb = toolbar(isFullscreen() ? FULLSCREEN_TOOLBAR : WINDOW_TOOLBAR);
if (tb.hwnd == 0) {
return;
}
std::map<int,ZLToolbar::ItemPtr>::const_iterator it = tb.TBItemByActionCode.find(actionCode);
if ((it == tb.TBItemByActionCode.end()) || it->second.isNull()) {
return;
}
switch (it->second->type()) {
default:
break;
case ZLToolbar::Item::PLAIN_BUTTON:
case ZLToolbar::Item::MENU_BUTTON:
case ZLToolbar::Item::TOGGLE_BUTTON:
onButtonPress((ZLToolbar::AbstractButtonItem&)*it->second);
break;
}
}
ZLQtApplicationWindow::~ZLQtApplicationWindow() {
if (isFullscreen()) {
myWindowStateOption.setValue(FULLSCREEN);
} else if (isMaximized()) {
myWindowStateOption.setValue(MAXIMIZED);
} else {
myWindowStateOption.setValue(NORMAL);
QPoint position = pos();
if (position.x() != -1) {
myXOption.setValue(position.x());
}
if (position.y() != -1) {
myYOption.setValue(position.y());
}
myWidthOption.setValue(width());
myHeightOption.setValue(height());
}
for (std::map<const ZLToolbar::Item*,QAction*>::iterator it = myActions.begin(); it != myActions.end(); ++it) {
if (it->second != 0) {
delete it->second;
}
}
}
void NaClApplication::DidChangeView(const pp::View& view) {
/* Fullscreen switch in progress */
if(_flags & Flag::FullscreenSwitchInProgress) {
/* Done, remove the progress flag */
if(isFullscreen() == bool(_flags & Flag::WillBeFullscreen)) {
_flags &= ~Flag::FullscreenSwitchInProgress;
_flags |= Flag::Redraw;
}
/* Don't process anything during the switch */
else return;
}
Vector2i size(view.GetRect().width(), view.GetRect().height());
/* Canvas resized */
if(_viewportSize != size) {
_graphics->ResizeBuffers(size.x(), size.y());
viewportEvent(_viewportSize = size);
}
drawEvent();
}
bool Window::setFullscreen(bool _fullscreen){
if (isFullscreen() == _fullscreen)
return 1;
DWORD style = GetWindowLong(m_hwnd, GWL_STYLE);
if (_fullscreen){
MONITORINFO mi = { sizeof(mi) };
if (GetWindowPlacement(m_hwnd, &m_windowPlacement) && GetMonitorInfo(MonitorFromWindow(m_hwnd, MONITOR_DEFAULTTOPRIMARY), &mi)){
SetWindowLong(m_hwnd, GWL_STYLE, style & ~WS_OVERLAPPEDWINDOW);
SetWindowPos(m_hwnd, HWND_TOP,
mi.rcMonitor.left, mi.rcMonitor.top,
mi.rcMonitor.right - mi.rcMonitor.left, mi.rcMonitor.bottom - mi.rcMonitor.top,
SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
return 1;
}
return 0;
}
else{
SetWindowLong(m_hwnd, GWL_STYLE, style | WS_OVERLAPPEDWINDOW);
SetWindowPlacement(m_hwnd, &m_windowPlacement);
SetWindowPos(m_hwnd, nullptr, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
}
return 1;
}
bool QWaylandWindow::createDecoration()
{
// so far only xdg-shell support this "unminimize" trick, may be moved elsewhere
if (mState == Qt::WindowMinimized) {
QWaylandXdgSurface *xdgSurface = dynamic_cast<QWaylandXdgSurface *>(mShellSurface);
if ( xdgSurface ) {
if (xdgSurface->isFullscreen()) {
setWindowStateInternal(Qt::WindowFullScreen);
} else if (xdgSurface->isMaximized()) {
setWindowStateInternal(Qt::WindowMaximized);
} else {
setWindowStateInternal(Qt::WindowNoState);
}
}
}
if (!mDisplay->supportsWindowDecoration())
return false;
static bool decorationPluginFailed = false;
bool decoration = false;
switch (window()->type()) {
case Qt::Window:
case Qt::Widget:
case Qt::Dialog:
case Qt::Tool:
case Qt::Drawer:
decoration = true;
break;
default:
break;
}
if (window()->flags() & Qt::FramelessWindowHint || isFullscreen())
decoration = false;
if (window()->flags() & Qt::BypassWindowManagerHint)
decoration = false;
if (decoration && !decorationPluginFailed) {
if (!mWindowDecoration) {
QStringList decorations = QWaylandDecorationFactory::keys();
if (decorations.empty()) {
qWarning() << "No decoration plugins available. Running with no decorations.";
decorationPluginFailed = true;
return false;
}
QString targetKey;
QByteArray decorationPluginName = qgetenv("QT_WAYLAND_DECORATION");
if (!decorationPluginName.isEmpty()) {
targetKey = QString::fromLocal8Bit(decorationPluginName);
if (!decorations.contains(targetKey)) {
qWarning() << "Requested decoration " << targetKey << " not found, falling back to default";
targetKey = QString(); // fallthrough
}
}
if (targetKey.isEmpty())
targetKey = decorations.first(); // first come, first served.
mWindowDecoration = QWaylandDecorationFactory::create(targetKey, QStringList());
if (!mWindowDecoration) {
qWarning() << "Could not create decoration from factory! Running with no decorations.";
decorationPluginFailed = true;
return false;
}
mWindowDecoration->setWaylandWindow(this);
if (subSurfaceWindow()) {
subSurfaceWindow()->adjustPositionOfChildren();
}
}
} else {
delete mWindowDecoration;
mWindowDecoration = 0;
}
return mWindowDecoration;
}
QApplicationWindow::~QApplicationWindow() {
if (!isFullscreen() && !isMaximized()) {
myWidthOption.setValue(width());
myHeightOption.setValue(height());
}
}
void
Gui::notify_key_event(gnash::key::code k, int modifier, bool pressed)
{
// Handle GUI shortcuts
if (pressed) {
if (k == gnash::key::ESCAPE) {
if (isFullscreen()) {
_stage->setStageDisplayState(movie_root::DISPLAYSTATE_NORMAL);
}
}
if (modifier & gnash::key::GNASH_MOD_CONTROL) {
switch (k) {
case gnash::key::o:
case gnash::key::O:
takeScreenShot();
break;
case gnash::key::r:
case gnash::key::R:
restart();
break;
case gnash::key::p:
case gnash::key::P:
pause();
break;
case gnash::key::l:
case gnash::key::L:
refreshView();
break;
case gnash::key::q:
case gnash::key::Q:
case gnash::key::w:
case gnash::key::W:
quit();
break;
case gnash::key::f:
case gnash::key::F:
toggleFullscreen();
break;
case gnash::key::h:
case gnash::key::H:
showUpdatedRegions(!showUpdatedRegions());
break;
case gnash::key::MINUS:
{
// Max interval allowed: 1 second (1FPS)
const size_t ni = std::min<size_t>(_interval + 2, 1000u);
setInterval(ni);
break;
}
case gnash::key::PLUS:
{
// Min interval allowed: 1/100 second (100FPS)
const size_t ni = std::max<size_t>(_interval - 2, 10u);
setInterval(ni);
break;
}
case gnash::key::EQUALS:
{
if (_stage) {
const float fps = _stage->getRootMovie().frameRate();
// Min interval allowed: 1/100 second (100FPS)
const size_t ni = 1000.0/fps;
setInterval(ni);
}
break;
}
default:
break;
}
#ifdef ENABLE_KEYBOARD_MOUSE_MOVEMENTS
if ( _keyboardMouseMovements ) {
int step = _keyboardMouseMovementsStep;
// x5 if SHIFT is pressed
if (modifier & gnash::key::GNASH_MOD_SHIFT) step *= 5;
switch (k) {
case gnash::key::UP:
{
int newx = _xpointer;
int newy = _ypointer-step;
if ( newy < 0 ) newy=0;
notifyMouseMove(newx, newy);
break;
}
case gnash::key::DOWN:
{
int newx = _xpointer;
int newy = _ypointer+step;
if ( newy >= _height ) newy = _height-1;
notifyMouseMove(newx, newy);
break;
}
case gnash::key::LEFT:
{
int newx = _xpointer-step;
int newy = _ypointer;
if ( newx < 0 ) newx = 0;
notifyMouseMove(newx, newy);
break;
}
case gnash::key::RIGHT:
{
const int newy = _ypointer;
int newx = _xpointer + step;
if ( newx >= _width ) newx = _width-1;
notifyMouseMove(newx, newy);
break;
}
default:
break;
}
}
#endif // ENABLE_KEYBOARD_MOUSE_MOVEMENTS
}
}
if (!_started) return;
if (_stopped) return;
if (_stage->keyEvent(k, pressed)) {
// any action triggered by the
// event required screen refresh
display(_stage);
}
}
void ShellSurface::move(Seat *seat)
{
if (isFullscreen()) {
return;
}
class MoveGrab : public PointerGrab
{
public:
void motion(uint32_t time, Pointer::MotionEvent evt) override
{
pointer()->move(evt);
QPointF pos = pointer()->motionToAbs(evt);
Output *out = grabbedView->output();
QRect surfaceGeometry = shsurf->geometry();
int moveX = pos.x() + dx;
int moveY = pos.y() + dy;
QPointF p = QPointF(moveX, moveY);
QPointF br = p + surfaceGeometry.bottomRight();
if (shsurf->m_shell->snapPos(out, br)) {
p = br - surfaceGeometry.bottomRight();
}
QPointF tl = p + surfaceGeometry.topLeft();
if (shsurf->m_shell->snapPos(out, tl)) {
p = tl - surfaceGeometry.topLeft();
}
shsurf->moveViews((int)p.x(), (int)p.y());
}
void button(uint32_t time, PointerButton button, Pointer::ButtonState state) override
{
if (pointer()->buttonCount() == 0 && state == Pointer::ButtonState::Released) {
end();
}
}
void ended() override
{
shsurf->m_currentGrab = nullptr;
delete this;
}
ShellSurface *shsurf;
View *grabbedView;
double dx, dy;
};
MoveGrab *move = new MoveGrab;
View *view = seat->pointer()->pickView()->mainView();
move->dx = view->x() - seat->pointer()->x();
move->dy = view->y() - seat->pointer()->y();
move->shsurf = this;
move->grabbedView = view;
move->start(seat, PointerCursor::Move);
m_currentGrab = move;
}