515 lines
16 KiB
C++
515 lines
16 KiB
C++
// This file is part of VSTGUI. It is subject to the license terms
|
|
// in the LICENSE file found in the top-level directory of this
|
|
// distribution and at http://github.com/steinbergmedia/vstgui/LICENSE
|
|
|
|
#include "window.h"
|
|
#include "application.h"
|
|
#include "../../lib/cframe.h"
|
|
#include "../../lib/controls/coptionmenu.h"
|
|
#include "../../lib/dispatchlist.h"
|
|
#include "../../lib/events.h"
|
|
#include "../../uidescription/icontroller.h"
|
|
#include "../include/iapplication.h"
|
|
#include "../include/icommand.h"
|
|
#include "../include/ipreference.h"
|
|
#include "../include/iwindowcontroller.h"
|
|
#include "platform/iplatformwindow.h"
|
|
|
|
#include <sstream>
|
|
#include <vector>
|
|
|
|
//------------------------------------------------------------------------
|
|
namespace VSTGUI {
|
|
namespace Standalone {
|
|
namespace Detail {
|
|
namespace /*anonymous*/ {
|
|
|
|
//------------------------------------------------------------------------
|
|
UTF8String strFromPositionAndSize (const CPoint& pos, const CPoint& size)
|
|
{
|
|
std::stringstream str;
|
|
str << pos.x << "," << pos.y << "," << size.x << "," << size.y;
|
|
return UTF8String (str.str ());
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
struct PosAndSize
|
|
{
|
|
CPoint pos;
|
|
CPoint size;
|
|
};
|
|
|
|
static CPoint nullPoint {0, 0};
|
|
|
|
//------------------------------------------------------------------------
|
|
PosAndSize positionAndSizeFromString (const UTF8String& str)
|
|
{
|
|
PosAndSize r;
|
|
std::vector<std::string> elements;
|
|
std::stringstream stream (str.getString ());
|
|
std::string item;
|
|
while (std::getline (stream, item, ','))
|
|
elements.emplace_back (item);
|
|
|
|
if (elements.size () != 4)
|
|
return r;
|
|
r.pos.x = UTF8StringView (elements[0].data ()).toDouble ();
|
|
r.pos.y = UTF8StringView (elements[1].data ()).toDouble ();
|
|
r.size.x = UTF8StringView (elements[2].data ()).toDouble ();
|
|
r.size.y = UTF8StringView (elements[3].data ()).toDouble ();
|
|
|
|
return r;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
} // anonymous
|
|
|
|
//------------------------------------------------------------------------
|
|
class Window : public IPlatformWindowAccess,
|
|
public Platform::IWindowDelegate,
|
|
public IMouseObserver,
|
|
public std::enable_shared_from_this<Window>
|
|
{
|
|
public:
|
|
bool init (const WindowConfiguration& config, const WindowControllerPtr& controller);
|
|
|
|
// IWindow
|
|
const WindowControllerPtr& getController () const override { return controller; }
|
|
CPoint getSize () const override { return platformWindow->getSize (); }
|
|
CPoint getPosition () const override { return platformWindow->getPosition (); }
|
|
double getScaleFactor () const override { return platformWindow->getScaleFactor (); }
|
|
CRect getFocusViewRect () const override;
|
|
const UTF8String& getTitle () const override { return title; }
|
|
WindowType getType () const override { return windowType; }
|
|
WindowStyle getStyle () const override { return windowStyle; }
|
|
const UTF8String& getAutoSaveFrameName () const override { return autoSaveFrameName; }
|
|
void setAutoSaveFrameName (const UTF8String& name) override { autoSaveFrameName = name; }
|
|
void setSize (const CPoint& newSize) override;
|
|
void setPosition (const CPoint& newPosition) override
|
|
{
|
|
platformWindow->setPosition (newPosition);
|
|
}
|
|
void setTitle (const UTF8String& newTitle) override
|
|
{
|
|
title = newTitle;
|
|
platformWindow->setTitle (newTitle);
|
|
}
|
|
void setContentView (const SharedPointer<CFrame>& newFrame) override;
|
|
void setRepresentedPath (const UTF8String& path) override;
|
|
WindowStyle changeStyle (WindowStyle stylesToAdd, WindowStyle stylesToRemove) override;
|
|
void show () override;
|
|
void hide () override { platformWindow->hide (); }
|
|
void close () override { platformWindow->close (); }
|
|
void activate () override { platformWindow->activate (); }
|
|
void registerWindowListener (IWindowListener* listener) override;
|
|
void unregisterWindowListener (IWindowListener* listener) override;
|
|
|
|
// IPlatformWindowAccess
|
|
InterfacePtr getPlatformWindow () const override { return platformWindow; }
|
|
CFrame* getFrame () const override { return frame; }
|
|
|
|
// Platform::IWindowDelegate
|
|
CPoint constraintSize (const CPoint& newSize) override;
|
|
void onSizeChanged (const CPoint& newSize) override;
|
|
void onPositionChanged (const CPoint& newPosition) override;
|
|
void onShow () override;
|
|
void onHide () override;
|
|
void onClosed () override;
|
|
bool canClose () override;
|
|
void onActivated () override;
|
|
void onDeactivated () override;
|
|
// ICommandHandler
|
|
bool canHandleCommand (const Command& command) override;
|
|
bool handleCommand (const Command& command) override;
|
|
|
|
// IMouseObserver
|
|
void onMouseEntered (CView*, CFrame* ) override {};
|
|
void onMouseExited (CView*, CFrame* ) override {};
|
|
void onMouseEvent (MouseEvent& event, CFrame*) override;
|
|
|
|
private:
|
|
WindowControllerPtr controller;
|
|
WindowStyle windowStyle;
|
|
WindowType windowType;
|
|
Platform::WindowPtr platformWindow;
|
|
SharedPointer<CFrame> frame;
|
|
UTF8String autoSaveFrameName;
|
|
UTF8String title;
|
|
DispatchList<IWindowListener*> windowListeners;
|
|
};
|
|
|
|
//------------------------------------------------------------------------
|
|
bool Window::init (const WindowConfiguration& config, const WindowControllerPtr& inController)
|
|
{
|
|
title = config.title;
|
|
windowStyle = config.style;
|
|
windowType = config.type;
|
|
platformWindow = Platform::makeWindow (config, *this);
|
|
if (platformWindow)
|
|
{
|
|
if (!config.autoSaveFrameName.empty ())
|
|
{
|
|
autoSaveFrameName = config.autoSaveFrameName;
|
|
}
|
|
controller = inController;
|
|
}
|
|
return platformWindow != nullptr;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void Window::setSize (const CPoint& newSize)
|
|
{
|
|
CPoint size (newSize);
|
|
if (controller)
|
|
size = controller->constraintSize (*this, size);
|
|
platformWindow->setSize (size);
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void Window::show ()
|
|
{
|
|
if (controller)
|
|
controller->beforeShow (*this);
|
|
bool positionChanged = false;
|
|
if (!autoSaveFrameName.empty ())
|
|
{
|
|
if (auto frameName = IApplication::instance ().getPreferences ().get (autoSaveFrameName))
|
|
{
|
|
auto ps = positionAndSizeFromString (*frameName);
|
|
if (ps.pos != nullPoint && ps.size != nullPoint)
|
|
{
|
|
setPosition (ps.pos);
|
|
setSize (ps.size);
|
|
positionChanged = true;
|
|
}
|
|
}
|
|
}
|
|
if (!positionChanged && windowStyle.isCentered ())
|
|
platformWindow->center ();
|
|
platformWindow->show ();
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void Window::setContentView (const SharedPointer<CFrame>& newFrame)
|
|
{
|
|
if (frame)
|
|
{
|
|
frame->unregisterMouseObserver (this);
|
|
frame->close ();
|
|
}
|
|
frame = newFrame;
|
|
if (!frame)
|
|
{
|
|
if (controller)
|
|
controller->onSetContentView (*this, frame);
|
|
return;
|
|
}
|
|
auto frameConfig =
|
|
controller ? controller->createPlatformFrameConfig (platformWindow->getPlatformType ()) :
|
|
nullptr;
|
|
frameConfig = platformWindow->prepareFrameConfig (std::move (frameConfig));
|
|
frame->open (platformWindow->getPlatformHandle (), platformWindow->getPlatformType (),
|
|
frameConfig.get ());
|
|
frame->registerMouseObserver (this);
|
|
platformWindow->onSetContentView (frame);
|
|
if (controller)
|
|
controller->onSetContentView (*this, frame);
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void Window::setRepresentedPath (const UTF8String& path)
|
|
{
|
|
platformWindow->setRepresentedPath (path);
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
WindowStyle Window::changeStyle (WindowStyle stylesToAdd, WindowStyle stylesToRemove)
|
|
{
|
|
windowStyle = platformWindow->changeStyle (stylesToAdd, stylesToRemove);
|
|
return windowStyle;
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------
|
|
CRect Window::getFocusViewRect () const
|
|
{
|
|
CRect result;
|
|
if (frame)
|
|
{
|
|
if (auto focusView = frame->getFocusView ())
|
|
{
|
|
result = focusView->getViewSize ();
|
|
focusView->translateToGlobal (result);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
CPoint Window::constraintSize (const CPoint& _newSize)
|
|
{
|
|
CPoint newSize (_newSize);
|
|
if (frame)
|
|
newSize = frame->checkSizeConstraint (newSize);
|
|
return controller ? controller->constraintSize (*this, newSize) : newSize;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void Window::onSizeChanged (const CPoint& newSize)
|
|
{
|
|
windowListeners.forEach (
|
|
[&] (IWindowListener* listener) { listener->onSizeChanged (*this, newSize); });
|
|
if (controller)
|
|
controller->onSizeChanged (*this, newSize);
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void Window::onPositionChanged (const CPoint& newPosition)
|
|
{
|
|
windowListeners.forEach (
|
|
[&] (IWindowListener* listener) { listener->onPositionChanged (*this, newPosition); });
|
|
if (controller)
|
|
controller->onPositionChanged (*this, newPosition);
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void Window::onClosed ()
|
|
{
|
|
auto self = shared_from_this (); // make sure we live as long as this method executes
|
|
|
|
if (!autoSaveFrameName.empty ())
|
|
IApplication::instance ().getPreferences ().set (
|
|
autoSaveFrameName, strFromPositionAndSize (getPosition (), getSize ()));
|
|
|
|
windowListeners.forEach ([&] (IWindowListener* listener) {
|
|
listener->onClosed (*this);
|
|
windowListeners.remove (listener);
|
|
});
|
|
if (controller)
|
|
controller->onClosed (*this);
|
|
platformWindow->onSetContentView (nullptr);
|
|
if (frame)
|
|
{
|
|
frame->unregisterMouseObserver (this);
|
|
frame->remember ();
|
|
frame->close ();
|
|
frame = nullptr;
|
|
}
|
|
controller = nullptr;
|
|
platformWindow = nullptr;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void Window::onShow ()
|
|
{
|
|
windowListeners.forEach ([&] (IWindowListener* listener) { listener->onShow (*this); });
|
|
if (controller)
|
|
controller->onShow (*this);
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void Window::onHide ()
|
|
{
|
|
windowListeners.forEach ([&] (IWindowListener* listener) { listener->onHide (*this); });
|
|
if (controller)
|
|
controller->onHide (*this);
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
bool Window::canClose ()
|
|
{
|
|
return controller ? controller->canClose (*this) : true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void Window::onActivated ()
|
|
{
|
|
windowListeners.forEach ([&] (IWindowListener* listener) { listener->onActivated (*this); });
|
|
if (controller)
|
|
controller->onActivated (*this);
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void Window::onDeactivated ()
|
|
{
|
|
windowListeners.forEach ([&] (IWindowListener* listener) { listener->onDeactivated (*this); });
|
|
if (controller)
|
|
controller->onDeactivated (*this);
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void Window::registerWindowListener (IWindowListener* listener)
|
|
{
|
|
windowListeners.add (listener);
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void Window::unregisterWindowListener (IWindowListener* listener)
|
|
{
|
|
windowListeners.remove (listener);
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
bool Window::canHandleCommand (const Command& command)
|
|
{
|
|
if (command == Commands::CloseWindow)
|
|
return controller->canClose (*this);
|
|
if (auto focusView = frame->getFocusView ())
|
|
{
|
|
if (auto viewController = getViewController (focusView, false))
|
|
{
|
|
if (auto commandHandler = dynamic_cast<ICommandHandler*> (viewController))
|
|
{
|
|
if (commandHandler->canHandleCommand (command))
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
if (auto commandHandler = dynamicPtrCast<ICommandHandler> (controller))
|
|
{
|
|
if (commandHandler->canHandleCommand (command))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
bool Window::handleCommand (const Command& command)
|
|
{
|
|
if (command == Commands::CloseWindow)
|
|
{
|
|
close ();
|
|
return true;
|
|
}
|
|
if (auto focusView = frame->getFocusView ())
|
|
{
|
|
if (auto viewController = getViewController (focusView, false))
|
|
{
|
|
if (auto commandHandler = dynamic_cast<ICommandHandler*> (viewController))
|
|
{
|
|
if (commandHandler->handleCommand (command))
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
if (auto commandHandler = dynamicPtrCast<ICommandHandler> (controller))
|
|
{
|
|
if (commandHandler->handleCommand (command))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
struct WindowContextMenuCommandHandler : ICommandMenuItemTarget, NonAtomicReferenceCounted
|
|
{
|
|
WindowContextMenuCommandHandler (Window* window) : window (window) {}
|
|
bool validateCommandMenuItem (CCommandMenuItem* item) override
|
|
{
|
|
Command cmd = {item->getCommandCategory (), item->getCommandName ()};
|
|
if (window->canHandleCommand (cmd) || getApplicationPlatformAccess ()->canHandleCommand (cmd))
|
|
return true;
|
|
item->setEnabled (false);
|
|
return false;
|
|
}
|
|
bool onCommandMenuItemSelected (CCommandMenuItem* item) override
|
|
{
|
|
Command cmd = {item->getCommandCategory (), item->getCommandName ()};
|
|
if (window->handleCommand (cmd))
|
|
return true;
|
|
return getApplicationPlatformAccess ()->handleCommand (cmd);
|
|
}
|
|
|
|
Window* window;
|
|
};
|
|
|
|
|
|
//------------------------------------------------------------------------
|
|
void Window::onMouseEvent (MouseEvent& event, CFrame* inFrame)
|
|
{
|
|
if (event.type != EventType::MouseDown || !event.buttonState.isRight ())
|
|
return;
|
|
|
|
auto contextMenu = makeOwned<COptionMenu> ();
|
|
|
|
CPoint where (event.mousePosition);
|
|
inFrame->getTransform ().transform (where);
|
|
|
|
CViewContainer::ViewList views;
|
|
if (inFrame->getViewsAt (where, views, GetViewOptions ().deep ().includeViewContainer ()))
|
|
{
|
|
for (const auto& view : views)
|
|
{
|
|
auto viewController = getViewController (view);
|
|
auto contextMenuController = dynamic_cast<IContextMenuController*> (viewController);
|
|
auto contextMenuController2 = dynamic_cast<IContextMenuController2*> (viewController);
|
|
if (contextMenuController == nullptr && contextMenuController2 == nullptr)
|
|
continue;
|
|
if (contextMenu->getNbEntries () != 0)
|
|
contextMenu->addSeparator ();
|
|
CPoint p (event.mousePosition);
|
|
view->frameToLocal (p);
|
|
if (contextMenuController2)
|
|
contextMenuController2->appendContextMenuItems (*contextMenu, view, p);
|
|
else if (contextMenuController)
|
|
contextMenuController->appendContextMenuItems (*contextMenu, p);
|
|
}
|
|
}
|
|
if (contextMenu->getNbEntries () == 0 &&
|
|
getApplicationPlatformAccess ()->getConfiguration ().showCommandsInWindowContextMenu)
|
|
{
|
|
auto commandList = getApplicationPlatformAccess ()->getCommandList (
|
|
staticPtrCast<Platform::IWindow> (getPlatformWindow ()).get ());
|
|
if (!commandList.empty ())
|
|
{
|
|
auto menuHandler = makeOwned<WindowContextMenuCommandHandler> (this);
|
|
for (const auto& cat : commandList)
|
|
{
|
|
auto item = new CMenuItem (cat.first);
|
|
auto catMenu = new COptionMenu ();
|
|
item->setSubmenu (catMenu);
|
|
for (const auto& entry : cat.second)
|
|
{
|
|
if (entry.name == CommandName::MenuSeparator)
|
|
{
|
|
catMenu->addSeparator ();
|
|
}
|
|
else
|
|
{
|
|
auto catItem =
|
|
new CCommandMenuItem ({entry.name, menuHandler, entry.group, entry.name});
|
|
catMenu->addEntry (catItem);
|
|
}
|
|
}
|
|
if (catMenu->getNbEntries () > 0)
|
|
contextMenu->addEntry (item);
|
|
else
|
|
item->forget ();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (contextMenu->getNbEntries () > 0)
|
|
{
|
|
contextMenu->cleanupSeparators (true);
|
|
contextMenu->setStyle (COptionMenu::kPopupStyle | COptionMenu::kMultipleCheckStyle);
|
|
contextMenu->popup (inFrame, event.mousePosition);
|
|
event.consumed = true;
|
|
castMouseDownEvent (event).ignoreFollowUpMoveAndUpEvents (true);
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
WindowPtr makeWindow (const WindowConfiguration& config, const WindowControllerPtr& controller)
|
|
{
|
|
auto window = std::make_shared<Detail::Window> ();
|
|
if (!window->init (config, controller))
|
|
return nullptr;
|
|
return window;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
} // Detail
|
|
} // Standalone
|
|
} // VSTGUI
|