From 3c725986457eb147f0e2b8d38c32a5aadcc139a9 Mon Sep 17 00:00:00 2001 From: dfighter1985 Date: Wed, 7 May 2014 00:50:57 +0200 Subject: [PATCH] Readding core plugin that was missing because of a hgignore entry. --HG-- branch : gsoc2014-dfighter --- .hgignore | 2 +- code/studio/src/plugins/core/CMakeLists.txt | 73 +++ .../src/plugins/core/context_manager.cpp | 167 ++++++ .../studio/src/plugins/core/context_manager.h | 76 +++ code/studio/src/plugins/core/core_constants.h | 121 +++++ code/studio/src/plugins/core/core_global.h | 30 ++ code/studio/src/plugins/core/core_plugin.cpp | 104 ++++ code/studio/src/plugins/core/core_plugin.h | 74 +++ .../plugins/core/general_settings_page.cpp | 241 +++++++++ .../src/plugins/core/general_settings_page.h | 74 +++ .../src/plugins/core/general_settings_page.ui | 233 +++++++++ .../plugins/core/icons/ic_nel_add_item.png | Bin 0 -> 3270 bytes .../src/plugins/core/icons/ic_nel_crash.png | Bin 0 -> 6630 bytes .../plugins/core/icons/ic_nel_delete_item.png | Bin 0 -> 1496 bytes .../plugins/core/icons/ic_nel_down_item.png | Bin 0 -> 3812 bytes .../core/icons/ic_nel_generic_settings.png | Bin 0 -> 5633 bytes .../src/plugins/core/icons/ic_nel_new.png | Bin 0 -> 21396 bytes .../src/plugins/core/icons/ic_nel_open.png | Bin 0 -> 4310 bytes .../core/icons/ic_nel_path_settings.png | Bin 0 -> 4557 bytes .../src/plugins/core/icons/ic_nel_pill.png | Bin 0 -> 9291 bytes .../src/plugins/core/icons/ic_nel_redo.png | Bin 0 -> 4694 bytes .../plugins/core/icons/ic_nel_reset_all.png | Bin 0 -> 5938 bytes .../src/plugins/core/icons/ic_nel_save.png | Bin 0 -> 43738 bytes .../src/plugins/core/icons/ic_nel_save_as.png | Bin 0 -> 52871 bytes .../src/plugins/core/icons/ic_nel_undo.png | Bin 0 -> 4714 bytes .../src/plugins/core/icons/ic_nel_up_item.png | Bin 0 -> 3304 bytes code/studio/src/plugins/core/icontext.h | 76 +++ code/studio/src/plugins/core/icore.h | 70 +++ code/studio/src/plugins/core/icore_listener.h | 63 +++ code/studio/src/plugins/core/images/nel.png | Bin 0 -> 15587 bytes .../src/plugins/core/images/preferences.png | Bin 0 -> 10286 bytes code/studio/src/plugins/core/ioptions_page.h | 75 +++ code/studio/src/plugins/core/main_window.cpp | 492 ++++++++++++++++++ code/studio/src/plugins/core/main_window.h | 147 ++++++ code/studio/src/plugins/core/menu_manager.cpp | 96 ++++ code/studio/src/plugins/core/menu_manager.h | 67 +++ .../src/plugins/core/ovqt_plugin_core.xml | 7 + .../src/plugins/core/plugin_view_dialog.cpp | 108 ++++ .../src/plugins/core/plugin_view_dialog.h | 58 +++ .../src/plugins/core/plugin_view_dialog.ui | 135 +++++ code/studio/src/plugins/core/qtwin.cpp | 241 +++++++++ code/studio/src/plugins/core/qtwin.h | 37 ++ .../core/search_paths_settings_page.cpp | 219 ++++++++ .../plugins/core/search_paths_settings_page.h | 74 +++ .../core/search_paths_settings_page.ui | 198 +++++++ .../src/plugins/core/settings_dialog.cpp | 182 +++++++ .../studio/src/plugins/core/settings_dialog.h | 75 +++ .../src/plugins/core/settings_dialog.ui | 126 +++++ 48 files changed, 3740 insertions(+), 1 deletion(-) create mode 100644 code/studio/src/plugins/core/CMakeLists.txt create mode 100644 code/studio/src/plugins/core/context_manager.cpp create mode 100644 code/studio/src/plugins/core/context_manager.h create mode 100644 code/studio/src/plugins/core/core_constants.h create mode 100644 code/studio/src/plugins/core/core_global.h create mode 100644 code/studio/src/plugins/core/core_plugin.cpp create mode 100644 code/studio/src/plugins/core/core_plugin.h create mode 100644 code/studio/src/plugins/core/general_settings_page.cpp create mode 100644 code/studio/src/plugins/core/general_settings_page.h create mode 100644 code/studio/src/plugins/core/general_settings_page.ui create mode 100644 code/studio/src/plugins/core/icons/ic_nel_add_item.png create mode 100644 code/studio/src/plugins/core/icons/ic_nel_crash.png create mode 100644 code/studio/src/plugins/core/icons/ic_nel_delete_item.png create mode 100644 code/studio/src/plugins/core/icons/ic_nel_down_item.png create mode 100644 code/studio/src/plugins/core/icons/ic_nel_generic_settings.png create mode 100644 code/studio/src/plugins/core/icons/ic_nel_new.png create mode 100644 code/studio/src/plugins/core/icons/ic_nel_open.png create mode 100644 code/studio/src/plugins/core/icons/ic_nel_path_settings.png create mode 100644 code/studio/src/plugins/core/icons/ic_nel_pill.png create mode 100644 code/studio/src/plugins/core/icons/ic_nel_redo.png create mode 100644 code/studio/src/plugins/core/icons/ic_nel_reset_all.png create mode 100644 code/studio/src/plugins/core/icons/ic_nel_save.png create mode 100644 code/studio/src/plugins/core/icons/ic_nel_save_as.png create mode 100644 code/studio/src/plugins/core/icons/ic_nel_undo.png create mode 100644 code/studio/src/plugins/core/icons/ic_nel_up_item.png create mode 100644 code/studio/src/plugins/core/icontext.h create mode 100644 code/studio/src/plugins/core/icore.h create mode 100644 code/studio/src/plugins/core/icore_listener.h create mode 100644 code/studio/src/plugins/core/images/nel.png create mode 100644 code/studio/src/plugins/core/images/preferences.png create mode 100644 code/studio/src/plugins/core/ioptions_page.h create mode 100644 code/studio/src/plugins/core/main_window.cpp create mode 100644 code/studio/src/plugins/core/main_window.h create mode 100644 code/studio/src/plugins/core/menu_manager.cpp create mode 100644 code/studio/src/plugins/core/menu_manager.h create mode 100644 code/studio/src/plugins/core/ovqt_plugin_core.xml create mode 100644 code/studio/src/plugins/core/plugin_view_dialog.cpp create mode 100644 code/studio/src/plugins/core/plugin_view_dialog.h create mode 100644 code/studio/src/plugins/core/plugin_view_dialog.ui create mode 100644 code/studio/src/plugins/core/qtwin.cpp create mode 100644 code/studio/src/plugins/core/qtwin.h create mode 100644 code/studio/src/plugins/core/search_paths_settings_page.cpp create mode 100644 code/studio/src/plugins/core/search_paths_settings_page.h create mode 100644 code/studio/src/plugins/core/search_paths_settings_page.ui create mode 100644 code/studio/src/plugins/core/settings_dialog.cpp create mode 100644 code/studio/src/plugins/core/settings_dialog.h create mode 100644 code/studio/src/plugins/core/settings_dialog.ui diff --git a/.hgignore b/.hgignore index 530c92512..5587652fd 100644 --- a/.hgignore +++ b/.hgignore @@ -43,7 +43,7 @@ default_c *.so *.so.* *_debug -core +core.* *.pc *.gch diff --git a/code/studio/src/plugins/core/CMakeLists.txt b/code/studio/src/plugins/core/CMakeLists.txt new file mode 100644 index 000000000..5a20ba46c --- /dev/null +++ b/code/studio/src/plugins/core/CMakeLists.txt @@ -0,0 +1,73 @@ +INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_BINARY_DIR} + ${CMAKE_CURRENT_SOURCE_DIR} + ${LIBXML2_INCLUDE_DIR} + ${QT_INCLUDES}) + +FILE(GLOB SRC *.cpp *.h) +SET(OVQT_EXT_SYS_SRC ${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin.h + ${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin_manager.h + ${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin_spec.h) + +SET(OVQT_CORE_PLUGIN_HDR + icore.h + icontext.h + icore_listener.h + ioptions_page.h + core_plugin.h + core.h + main_window.h + menu_manager.h + context_manager.h + settings_dialog.h + search_paths_settings_page.h + general_settings_page.h + plugin_view_dialog.h +) + +SET(OVQT_CORE_PLUGIN_UIS settings_dialog.ui + plugin_view_dialog.ui + general_settings_page.ui + search_paths_settings_page.ui +) + +SET(OVQT_CORE_PLUGIN_RCS core.qrc) + +SET(QT_USE_QTGUI TRUE) +SET(QT_USE_QTOPENGL TRUE) + +QT4_ADD_RESOURCES(OVQT_CORE_PLUGIN_RC_SRCS ${OVQT_CORE_PLUGIN_RCS}) +QT4_WRAP_CPP(OVQT_CORE_PLUGIN_MOC_SRC ${OVQT_CORE_PLUGIN_HDR}) +QT4_WRAP_UI(OVQT_CORE_PLUGIN_UI_HDRS ${OVQT_CORE_PLUGIN_UIS}) + +SOURCE_GROUP(QtResources FILES ${OVQT_CORE_PLUGIN_UIS} ${OVQT_CORE_PLUGIN_RCS}) +SOURCE_GROUP(QtGeneratedUiHdr FILES ${OVQT_CORE_PLUGIN_UI_HDRS}) +SOURCE_GROUP(QtGeneratedMocSrc FILES ${OVQT_CORE_PLUGIN_MOC_SRC}) +SOURCE_GROUP("Core Plugin" FILES ${SRC}) +SOURCE_GROUP("OVQT Extension System" FILES ${OVQT_EXT_SYS_SRC}) + +ADD_LIBRARY(ovqt_plugin_core SHARED ${SRC} ${OVQT_CORE_PLUGIN_MOC_SRC} ${OVQT_EXT_SYS_SRC} ${OVQT_CORE_PLUGIN_RC_SRCS} ${OVQT_CORE_PLUGIN_UI_HDRS}) + +TARGET_LINK_LIBRARIES(ovqt_plugin_core nelmisc ${QT_LIBRARIES}) + +NL_DEFAULT_PROPS(ovqt_plugin_core "NeL, Tools, 3D: Object Viewer Qt Plugin: Core") +NL_ADD_RUNTIME_FLAGS(ovqt_plugin_core) +NL_ADD_LIB_SUFFIX(ovqt_plugin_core) + +ADD_DEFINITIONS(-DCORE_LIBRARY ${LIBXML2_DEFINITIONS} -DQT_PLUGIN -DQT_SHARED ${QT_DEFINITIONS}) + +IF(WIN32) + IF(WITH_INSTALL_LIBRARIES) + INSTALL(TARGETS ovqt_plugin_core LIBRARY DESTINATION ${OVQT_PLUGIN_DIR} ARCHIVE DESTINATION ${NL_LIB_PREFIX} RUNTIME DESTINATION ${OVQT_PLUGIN_DIR} COMPONENT tools3d) + ELSE(WITH_INSTALL_LIBRARIES) + INSTALL(TARGETS ovqt_plugin_core LIBRARY DESTINATION ${OVQT_PLUGIN_DIR} RUNTIME DESTINATION ${OVQT_PLUGIN_DIR} COMPONENT tools3d) + ENDIF(WITH_INSTALL_LIBRARIES) +ELSE(WIN32) + IF(WITH_INSTALL_LIBRARIES) + INSTALL(TARGETS ovqt_plugin_core LIBRARY DESTINATION ${OVQT_PLUGIN_DIR} ARCHIVE DESTINATION ${NL_LIB_PREFIX} RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT tools3d) + ELSE(WITH_INSTALL_LIBRARIES) + INSTALL(TARGETS ovqt_plugin_core LIBRARY DESTINATION ${OVQT_PLUGIN_DIR} RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT tools3d) + ENDIF(WITH_INSTALL_LIBRARIES) +ENDIF(WIN32) + +INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/ovqt_plugin_core.xml DESTINATION ${OVQT_PLUGIN_SPECS_DIR} COMPONENT tools3d) + diff --git a/code/studio/src/plugins/core/context_manager.cpp b/code/studio/src/plugins/core/context_manager.cpp new file mode 100644 index 000000000..8355b5cb8 --- /dev/null +++ b/code/studio/src/plugins/core/context_manager.cpp @@ -0,0 +1,167 @@ +// Object Viewer Qt - MMORPG Framework +// Copyright (C) 2010 Winch Gate Property Limited +// Copyright (C) 2011 Dzmitry Kamiahin +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +// Project includes +#include "context_manager.h" +#include "icontext.h" +#include "main_window.h" + +// NeL includes +#include + +// Qt includes +#include +#include + +namespace Core +{ + +struct ContextManagerPrivate +{ + explicit ContextManagerPrivate(Core::MainWindow *mainWindow, QTabWidget *tabWidget); + Core::MainWindow *m_mainWindow; + QTabWidget *m_tabWidget; + QVector m_contexts; + int m_oldCurrent; +}; + +ContextManagerPrivate::ContextManagerPrivate(Core::MainWindow *mainWindow, QTabWidget *tabWidget) + : m_mainWindow(mainWindow), + m_tabWidget(tabWidget), + m_oldCurrent(-1) +{ +} + +ContextManager::ContextManager(Core::MainWindow *mainWindow, QTabWidget *tabWidget) + : d(new ContextManagerPrivate(mainWindow, tabWidget)) +{ + QObject::connect(d->m_mainWindow->pluginManager(), SIGNAL(objectAdded(QObject *)), + this, SLOT(objectAdded(QObject *))); + QObject::connect(d->m_mainWindow->pluginManager(), SIGNAL(aboutToRemoveObject(QObject *)), + this, SLOT(aboutToRemoveObject(QObject *))); + + QObject::connect(d->m_tabWidget, SIGNAL(currentChanged(int)), this, SLOT(currentTabChanged(int))); +} + +ContextManager::~ContextManager() +{ + delete d; +} + +Core::IContext *ContextManager::currentContext() const +{ + int currentIndex = d->m_tabWidget->currentIndex(); + if (currentIndex < 0) + return 0; + return d->m_contexts.at(currentIndex); +} + +Core::IContext *ContextManager::context(const QString &id) const +{ + const int index = indexOf(id); + if (index >= 0) + return d->m_contexts.at(index); + return 0; +} + +void ContextManager::registerUndoStack(QUndoStack *stack) +{ + nlassert(stack); + d->m_mainWindow->undoGroup()->addStack(stack); +} + +void ContextManager::unregisterUndoStack(QUndoStack *stack) +{ + nlassert(stack); + d->m_mainWindow->undoGroup()->removeStack(stack); +} + +void ContextManager::activateContext(const QString &id) +{ + const int index = indexOf(id); + if (index >= 0) + d->m_tabWidget->setCurrentIndex(index); +} + +void ContextManager::updateCurrentContext() +{ + d->m_mainWindow->updateContext(currentContext()); +} + +void ContextManager::objectAdded(QObject *obj) +{ + IContext *context = qobject_cast(obj); + if (context) + addContextObject(context); +} + +void ContextManager::aboutToRemoveObject(QObject *obj) +{ + IContext *context = qobject_cast(obj); + if (context) + removeContextObject(context); +} + +void ContextManager::addContextObject(IContext *context) +{ + d->m_contexts.push_back(context); + d->m_mainWindow->addContextObject(context); + + QWidget *tabWidget = new QWidget(d->m_tabWidget); + d->m_tabWidget->addTab(tabWidget, context->icon(), context->trName()); + QGridLayout *gridLayout = new QGridLayout(tabWidget); + gridLayout->setObjectName(QString::fromUtf8("gridLayout_") + context->id()); + gridLayout->setContentsMargins(0, 0, 0, 0); + gridLayout->addWidget(context->widget(), 0, 0, 1, 1); +} + +void ContextManager::removeContextObject(IContext *context) +{ + d->m_mainWindow->removeContextObject(context); + + const int index = indexOf(context->id()); + QWidget *widget = d->m_tabWidget->widget(index); + d->m_tabWidget->removeTab(index); + d->m_contexts.remove(index); + delete widget; +} + +void ContextManager::currentTabChanged(int index) +{ + if (index >= 0) + { + IContext *context = d->m_contexts.at(index); + IContext *oldContext = 0; + if (d->m_oldCurrent >= 0) + oldContext = d->m_contexts.at(d->m_oldCurrent); + d->m_oldCurrent = index; + Q_EMIT currentContextChanged(context, oldContext); + } +} + +int ContextManager::indexOf(const QString &id) const +{ + for (int i = 0; i < d->m_contexts.count(); ++i) + { + if (d->m_contexts.at(i)->id() == id) + return i; + } + nlwarning(QString("Warning, no such context: %1").arg(id).toUtf8().constData()); + return -1; +} + +} /* namespace Core */ \ No newline at end of file diff --git a/code/studio/src/plugins/core/context_manager.h b/code/studio/src/plugins/core/context_manager.h new file mode 100644 index 000000000..8151648e7 --- /dev/null +++ b/code/studio/src/plugins/core/context_manager.h @@ -0,0 +1,76 @@ +// Object Viewer Qt - MMORPG Framework +// Copyright (C) 2010 Winch Gate Property Limited +// Copyright (C) 2011 Dzmitry Kamiahin +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +#ifndef CONTEXT_MANAGER_H +#define CONTEXT_MANAGER_H + +// Project includes +#include "core_global.h" + +// Qt includes +#include + +QT_BEGIN_NAMESPACE +class QTabWidget; +class QUndoStack; +QT_END_NAMESPACE + +namespace Core +{ +class IContext; +class MainWindow; +struct ContextManagerPrivate; + +class CORE_EXPORT ContextManager : public QObject +{ + Q_OBJECT + +public: + explicit ContextManager(Core::MainWindow *mainWindow, QTabWidget *tabWidget); + virtual ~ContextManager(); + + Core::IContext *currentContext() const; + Core::IContext *context(const QString &id) const; + + // temporary solution for multiple undo stacks per context + void registerUndoStack(QUndoStack *stack); + void unregisterUndoStack(QUndoStack *stack); + +Q_SIGNALS: + // the default argument '=0' is important for connects without the oldContext argument. + void currentContextChanged(Core::IContext *context, Core::IContext *oldContext = 0); + +public Q_SLOTS: + void activateContext(const QString &id); + void updateCurrentContext(); + +private Q_SLOTS: + void objectAdded(QObject *obj); + void aboutToRemoveObject(QObject *obj); + void addContextObject(IContext *context); + void removeContextObject(IContext *context); + void currentTabChanged(int index); + +private: + int indexOf(const QString &id) const; + + ContextManagerPrivate *d; +}; + +} // namespace Core + +#endif // CONTEXT_MANAGER_H diff --git a/code/studio/src/plugins/core/core_constants.h b/code/studio/src/plugins/core/core_constants.h new file mode 100644 index 000000000..8bf6d5fcd --- /dev/null +++ b/code/studio/src/plugins/core/core_constants.h @@ -0,0 +1,121 @@ +// Object Viewer Qt - MMORPG Framework +// Copyright (C) 2010 Winch Gate Property Limited +// Copyright (C) 2010 Dzmitry Kamiahin +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +#ifndef CORE_CONSTANTS_H +#define CORE_CONSTANTS_H + +namespace Core +{ +namespace Constants +{ + +const char *const OVQT_VERSION_LONG = "0.8"; +const char *const OVQT_VENDOR = "Ryzom Core"; +const char *const OVQT_YEAR = "2010, 2011"; +const char *const OVQT_CORE_PLUGIN = "Core"; + +//mainwindow +const char *const MAIN_WINDOW = "ObjectViewerQt.MainWindow"; + +//menubar +const char *const MENU_BAR = "ObjectViewerQt.MenuBar"; + +//menus +const char *const M_FILE = "ObjectViewerQt.Menu.File"; +const char *const M_EDIT = "ObjectViewerQt.Menu.Edit"; +const char *const M_VIEW = "ObjectViewerQt.Menu.View"; +const char *const M_SCENE = "ObjectViewerQt.Menu.Scene"; +const char *const M_TOOLS = "ObjectViewerQt.Menu.Tools"; +const char *const M_WINDOW = "ObjectViewerQt.Menu.Window"; +const char *const M_HELP = "ObjectViewerQt.Menu.Help"; + +const char *const M_FILE_RECENTFILES = "ObjectViewerQt.Menu.File.RecentFiles"; +const char *const M_SHEET = "ObjectViewerQt.Menu.Sheet"; + +//actions +const char *const NEW = "ObjectViewerQt.New"; +const char *const OPEN = "ObjectViewerQt.Open"; +const char *const SAVE = "ObjectViewerQt.Save"; +const char *const SAVE_AS = "ObjectViewerQt.SaveAs"; +const char *const SAVE_ALL = "ObjectViewerQt.SaveAll"; +const char *const EXIT = "ObjectViewerQt.Exit"; + +const char *const UNDO = "ObjectViewerQt.Undo"; +const char *const REDO = "ObjectViewerQt.Redo"; +const char *const CUT = "ObjectViewerQt.Cut"; +const char *const COPY = "ObjectViewerQt.Copy"; +const char *const PASTE = "ObjectViewerQt.Paste"; +const char *const DEL = "ObjectViewerQt.Del"; +const char *const FIND = "ObjectViewerQt.Find"; +const char *const SELECT_ALL = "ObjectViewerQt.SelectAll"; +const char *const GOTO_POS = "ObjectViewerQt.Goto"; + +const char *const SETTINGS = "ObjectViewerQt.Settings"; +const char *const TOGGLE_FULLSCREEN = "ObjectViewerQt.ToggleFullScreen"; + +const char *const CLOSE = "ObjectViewerQt.Close"; +const char *const CLOSEALL = "ObjectViewerQt.CloseAll"; +const char *const CLOSEOTHERS = "ObjectViewerQt.CloseOthers"; +const char *const ABOUT = "ObjectViewerQt.About"; +const char *const ABOUT_PLUGINS = "ObjectViewerQt.AboutPlugins"; +const char *const ABOUT_QT = "ObjectViewerQt.AboutQt"; + +//settings +const char *const SETTINGS_CATEGORY_GENERAL = "general"; +const char *const SETTINGS_CATEGORY_GENERAL_ICON = ":/icons/ic_nel_generic_settings.png"; +const char *const SETTINGS_TR_CATEGORY_GENERAL = QT_TR_NOOP("General"); + +const char *const MAIN_WINDOW_SECTION = "MainWindow"; +const char *const MAIN_WINDOW_STATE = "WindowState"; +const char *const MAIN_WINDOW_GEOMETRY = "WindowGeometry"; +const char *const QT_STYLE = "QtStyle"; +const char *const QT_PALETTE = "QtPalette"; + +const char *const LANGUAGE = "Language"; +const char *const PLUGINS_PATH = "PluginPath"; +const char *const DATA_PATH_SECTION = "DataPath"; +const char *const SEARCH_PATHS = "SearchPaths"; +const char *const RECURSIVE_SEARCH_PATHS = "RecursiveSearchPathes"; +const char *const LEVELDESIGN_PATH = "LevelDesignPath"; +const char *const PRIMITIVES_PATH = "PrimitivesPath"; +const char *const ASSETS_PATH = "AssetsPath"; +const char *const LIGOCONFIG_FILE = "LigoConfigFile"; +const char *const REMAP_EXTENSIONS = "RemapExtensions"; + +const char *const LOG_SECTION = "LogSettings"; +const char *const LOG_ERROR = "LogError"; +const char *const LOG_WARNING = "LogWarning"; +const char *const LOG_DEBUG = "LogDebug"; +const char *const LOG_ASSERT = "LogAssert"; +const char *const LOG_INFO = "LogInfo"; + +//resources +const char *const ICON_NEL = ":/core/images/nel.png"; +const char *const ICON_SETTINGS = ":/core/images/preferences.png"; +const char *const ICON_PILL = ":/core/icons/ic_nel_pill.png"; +const char *const ICON_OPEN = ":/core/icons/ic_nel_open.png"; +const char *const ICON_NEW = ":/core/icons/ic_nel_new.png"; +const char *const ICON_SAVE = ":/core/icons/ic_nel_save.png"; +const char *const ICON_SAVE_AS = ":/core/icons/ic_nel_save_as.png"; +const char *const ICON_CRASH = ":/core/icons/ic_nel_crash.png"; +const char *const ICON_UNDO = ":/core/icons/ic_nel_undo.png"; +const char *const ICON_REDO = ":/core/icons/ic_nel_redo.png"; + +} // namespace Constants +} // namespace Core + +#endif // CORE_CONSTANTS_H diff --git a/code/studio/src/plugins/core/core_global.h b/code/studio/src/plugins/core/core_global.h new file mode 100644 index 000000000..48fe0ece9 --- /dev/null +++ b/code/studio/src/plugins/core/core_global.h @@ -0,0 +1,30 @@ +// Object Viewer Qt - MMORPG Framework +// Copyright (C) 2010 Winch Gate Property Limited +// Copyright (C) 2011 Dzmitry Kamiahin +// Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +#ifndef CORE_GLOBAL_H +#define CORE_GLOBAL_H + +#include + +#if defined(CORE_LIBRARY) +# define CORE_EXPORT Q_DECL_EXPORT +#else +# define CORE_EXPORT Q_DECL_IMPORT +#endif + +#endif // CORE_GLOBAL_H diff --git a/code/studio/src/plugins/core/core_plugin.cpp b/code/studio/src/plugins/core/core_plugin.cpp new file mode 100644 index 000000000..a72a68ccc --- /dev/null +++ b/code/studio/src/plugins/core/core_plugin.cpp @@ -0,0 +1,104 @@ +// Object Viewer Qt - MMORPG Framework +// Copyright (C) 2010 Winch Gate Property Limited +// Copyright (C) 2010 Dzmitry Kamiahin +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +// Project includes +#include "core_plugin.h" +#include "settings_dialog.h" +#include "core_constants.h" +#include "search_paths_settings_page.h" +#include "general_settings_page.h" +#include "../../extension_system/iplugin_spec.h" + +// NeL includes +#include "nel/misc/debug.h" + +// Qt includes +#include +#include +#include +#include +#include +#include + +using namespace Core; + +CorePlugin::CorePlugin() + : m_plugMan(0), + m_mainWindow(0) +{ +} + +CorePlugin::~CorePlugin() +{ + Q_FOREACH(QObject *obj, m_autoReleaseObjects) + { + m_plugMan->removeObject(obj); + } + qDeleteAll(m_autoReleaseObjects); + m_autoReleaseObjects.clear(); + + if (m_mainWindow) + delete m_mainWindow; +} + +bool CorePlugin::initialize(ExtensionSystem::IPluginManager *pluginManager, QString *errorString) +{ + Q_UNUSED(errorString); + m_plugMan = pluginManager; + + m_mainWindow = new MainWindow(pluginManager); + bool success = m_mainWindow->initialize(errorString); + + GeneralSettingsPage *generalSettings = new GeneralSettingsPage(this); + SearchPathsSettingsPage *searchPathPage = new SearchPathsSettingsPage(false, this); + SearchPathsSettingsPage *recureseSearchPathPage = new SearchPathsSettingsPage(true, this); + + generalSettings->applyGeneralSettings(); + searchPathPage->applySearchPaths(); + recureseSearchPathPage->applySearchPaths(); + addAutoReleasedObject(generalSettings); + addAutoReleasedObject(searchPathPage); + addAutoReleasedObject(recureseSearchPathPage); + return success; +} + +void CorePlugin::extensionsInitialized() +{ + m_mainWindow->extensionsInitialized(); +} + +void CorePlugin::shutdown() +{ +} + +void CorePlugin::setNelContext(NLMISC::INelContext *nelContext) +{ +#ifdef NL_OS_WINDOWS + // Ensure that a context doesn't exist yet. + // This only applies to platforms without PIC, e.g. Windows. + nlassert(!NLMISC::INelContext::isContextInitialised()); +#endif // NL_OS_WINDOWS + m_libContext = new NLMISC::CLibraryContext(*nelContext); +} + +void CorePlugin::addAutoReleasedObject(QObject *obj) +{ + m_plugMan->addObject(obj); + m_autoReleaseObjects.prepend(obj); +} + +Q_EXPORT_PLUGIN(CorePlugin) diff --git a/code/studio/src/plugins/core/core_plugin.h b/code/studio/src/plugins/core/core_plugin.h new file mode 100644 index 000000000..5062227e3 --- /dev/null +++ b/code/studio/src/plugins/core/core_plugin.h @@ -0,0 +1,74 @@ +// Object Viewer Qt - MMORPG Framework +// Copyright (C) 2010 Winch Gate Property Limited +// Copyright (C) 2010 Dzmitry Kamiahin +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +#ifndef CORE_PLUGIN_H +#define CORE_PLUGIN_H + +#include "../../extension_system/iplugin.h" +#include "main_window.h" + +#include "nel/misc/app_context.h" + +#include + +namespace NLMISC +{ +class CLibraryContext; +} + +namespace ExtensionSystem +{ +class IPluginSpec; +} + +namespace Core +{ + +class CorePlugin : public QObject, public ExtensionSystem::IPlugin +{ + Q_OBJECT + Q_INTERFACES(ExtensionSystem::IPlugin) +public: + + CorePlugin(); + virtual ~CorePlugin(); + + bool initialize(ExtensionSystem::IPluginManager *pluginManager, QString *errorString); + void extensionsInitialized(); + void shutdown(); + + void setNelContext(NLMISC::INelContext *nelContext); + + void addAutoReleasedObject(QObject *obj); + + ExtensionSystem::IPluginManager *pluginManager() const + { + return m_plugMan; + } + +protected: + NLMISC::CLibraryContext *m_libContext; + +private: + ExtensionSystem::IPluginManager *m_plugMan; + MainWindow *m_mainWindow; + QList m_autoReleaseObjects; +}; + +} // namespace Core + +#endif // CORE_PLUGIN_H diff --git a/code/studio/src/plugins/core/general_settings_page.cpp b/code/studio/src/plugins/core/general_settings_page.cpp new file mode 100644 index 000000000..bfbb06d66 --- /dev/null +++ b/code/studio/src/plugins/core/general_settings_page.cpp @@ -0,0 +1,241 @@ +// Object Viewer Qt - MMORPG Framework +// Copyright (C) 2010 Winch Gate Property Limited +// Copyright (C) 2011 Dzmitry Kamiahin +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +// Project includes +#include "general_settings_page.h" +#include "core_constants.h" +#include "icore.h" + +// NeL includes +#include + +// Qt includes +#include +#include +#include +#include +#include +#include + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +namespace Core +{ + +GeneralSettingsPage::GeneralSettingsPage(QObject *parent) + : IOptionsPage(parent), + m_page(0) +{ + m_originalPalette = QApplication::palette(); +} + +GeneralSettingsPage::~GeneralSettingsPage() +{ +} + +QString GeneralSettingsPage::id() const +{ + return QLatin1String("general_settings"); +} + +QString GeneralSettingsPage::trName() const +{ + return tr("General"); +} + +QString GeneralSettingsPage::category() const +{ + return QLatin1String(Constants::SETTINGS_CATEGORY_GENERAL); +} + +QString GeneralSettingsPage::trCategory() const +{ + return tr(Constants::SETTINGS_TR_CATEGORY_GENERAL); +} + +QIcon GeneralSettingsPage::categoryIcon() const +{ + return QIcon(); +} + +void GeneralSettingsPage::applyGeneralSettings() +{ + QSettings *settings = Core::ICore::instance()->settings(); + + settings->beginGroup(Constants::MAIN_WINDOW_SECTION); + QApplication::setStyle(QStyleFactory::create(settings->value(Constants::QT_STYLE, "").toString())); + + if (settings->value(Constants::QT_PALETTE, true).toBool()) + QApplication::setPalette(QApplication::style()->standardPalette()); + else + QApplication::setPalette(m_originalPalette); + settings->endGroup(); + + QString levelDesignPrefix; +#if defined(_DEBUG) && defined(NL_OS_WINDOWS) + levelDesignPrefix = "l:"; +#else + levelDesignPrefix = QString("%1/data_leveldesign").arg(RYZOM_SHARE_PREFIX); +#endif + + // Add primitives path and ligo config file to CPath + settings->beginGroup(Core::Constants::DATA_PATH_SECTION); + QString primitivePath = settings->value(Core::Constants::PRIMITIVES_PATH, QString("%1/primitives").arg(levelDesignPrefix)).toString(); + QString ligoConfigFile = settings->value(Core::Constants::LIGOCONFIG_FILE, QString("%1/leveldesign/world_editor_files/world_editor_classes.xml").arg(levelDesignPrefix)).toString(); + QString leveldesignPath = settings->value(Core::Constants::LEVELDESIGN_PATH, QString("%1/leveldesign").arg(levelDesignPrefix)).toString(); + NLMISC::CPath::addSearchPath(primitivePath.toUtf8().constData(), true, false); + NLMISC::CPath::display(); + NLMISC::CPath::addSearchFile(ligoConfigFile.toUtf8().constData()); + NLMISC::CPath::addSearchPath(leveldesignPath.toUtf8().constData(), true, false); + settings->endGroup(); +} + +QWidget *GeneralSettingsPage::createPage(QWidget *parent) +{ + m_page = new QWidget(parent); + m_ui.setupUi(m_page); + + readSettings(); + connect(m_ui.languageComboBox, SIGNAL(currentIndexChanged(QString)), this, SLOT(changeLanguage(QString))); + connect(m_ui.pluginsPathButton, SIGNAL(clicked()), this, SLOT(setPluginsPath())); + connect(m_ui.leveldesignPathButton, SIGNAL(clicked()), this, SLOT(setLevelDesignPath())); + connect(m_ui.assetsPathButton, SIGNAL(clicked()), this, SLOT(setAssetsPath())); + connect(m_ui.primitivesPathButton, SIGNAL(clicked()), this, SLOT(setPrimitivesPath())); + connect(m_ui.ligoConfigFileButton, SIGNAL(clicked()), this, SLOT(setLigoConfigFile())); + return m_page; +} + +void GeneralSettingsPage::apply() +{ + writeSettings(); + applyGeneralSettings(); +} + +void GeneralSettingsPage::finish() +{ + delete m_page; + m_page = 0; +} + +void GeneralSettingsPage::changeLanguage(const QString &lang) +{ + QMessageBox::information(0, tr("Restart required"), + tr("The language change will take effect after a restart of Object Viewer Qt.")); +} + +void GeneralSettingsPage::setPluginsPath() +{ + QString newPath = QFileDialog::getExistingDirectory(0, tr("Set the plugins path"), + m_ui.pluginsPathLineEdit->text()); + if (!newPath.isEmpty()) + { + m_ui.pluginsPathLineEdit->setText(newPath); + } +} + +void GeneralSettingsPage::setLevelDesignPath() +{ + QString newPath = QFileDialog::getExistingDirectory(0, tr("Set the level design path"), + m_ui.leveldesignPathLineEdit->text()); + if (!newPath.isEmpty()) + { + m_ui.leveldesignPathLineEdit->setText(newPath); + } +} + +void GeneralSettingsPage::setPrimitivesPath() +{ + QString newPath = QFileDialog::getExistingDirectory(0, tr("Set the primitives path"), + m_ui.primitivesPathLineEdit->text()); + if (!newPath.isEmpty()) + { + m_ui.primitivesPathLineEdit->setText(newPath); + } +} + +void GeneralSettingsPage::setLigoConfigFile() +{ + QString newFile = QFileDialog::getOpenFileName(0, tr("Set the ligo config file"), + m_ui.ligoConfigFileLineEdit->text()); + if (!newFile.isEmpty()) + { + m_ui.ligoConfigFileLineEdit->setText(newFile); + } +} + + +void GeneralSettingsPage::setAssetsPath() +{ + QString newPath = QFileDialog::getExistingDirectory(0, tr("Set the assets path"), + m_ui.assetsPathLineEdit->text()); + if (!newPath.isEmpty()) + { + m_ui.assetsPathLineEdit->setText(newPath); + } +} + +void GeneralSettingsPage::readSettings() +{ + QSettings *settings = Core::ICore::instance()->settings(); + + m_ui.pluginsPathLineEdit->setText(settings->value(Core::Constants::PLUGINS_PATH, "./plugins").toString()); + + settings->beginGroup(Constants::MAIN_WINDOW_SECTION); + m_ui.styleComboBox->addItems(QStyleFactory::keys()); + QString style = settings->value(Constants::QT_STYLE, "").toString(); + if (style == "") + m_ui.styleComboBox->setCurrentIndex(0); + else + m_ui.styleComboBox->setCurrentIndex(m_ui.styleComboBox->findText(style)); + m_ui.paletteCheckBox->setChecked(settings->value(Constants::QT_PALETTE, true).toBool()); + settings->endGroup(); + + QStringList paths; + settings->beginGroup(Core::Constants::DATA_PATH_SECTION); + m_ui.leveldesignPathLineEdit->setText(settings->value(Core::Constants::LEVELDESIGN_PATH, "l:/leveldesign").toString()); + m_ui.assetsPathLineEdit->setText(settings->value(Core::Constants::ASSETS_PATH, "w:/database").toString()); + m_ui.primitivesPathLineEdit->setText(settings->value(Core::Constants::PRIMITIVES_PATH, "l:/primitives").toString()); + m_ui.ligoConfigFileLineEdit->setText(settings->value(Core::Constants::LIGOCONFIG_FILE, "l:/leveldesign/world_editor_files/world_editor_classes.xml").toString()); + settings->endGroup(); +} + +void GeneralSettingsPage::writeSettings() +{ + QSettings *settings = Core::ICore::instance()->settings(); + + settings->setValue(Core::Constants::PLUGINS_PATH, m_ui.pluginsPathLineEdit->text()); + + settings->beginGroup(Constants::MAIN_WINDOW_SECTION); + if (m_ui.styleComboBox->currentIndex() == 0) + settings->setValue(Constants::QT_STYLE, ""); + else + settings->setValue(Constants::QT_STYLE, m_ui.styleComboBox->currentText()); + settings->setValue(Constants::QT_PALETTE, m_ui.paletteCheckBox->isChecked()); + settings->endGroup(); + + settings->beginGroup(Core::Constants::DATA_PATH_SECTION); + settings->setValue(Core::Constants::LEVELDESIGN_PATH, m_ui.leveldesignPathLineEdit->text()); + settings->setValue(Core::Constants::ASSETS_PATH, m_ui.assetsPathLineEdit->text()); + settings->setValue(Core::Constants::PRIMITIVES_PATH, m_ui.primitivesPathLineEdit->text()); + settings->setValue(Core::Constants::LIGOCONFIG_FILE, m_ui.ligoConfigFileLineEdit->text()); + settings->endGroup(); + settings->sync(); +} + +} /* namespace Core */ \ No newline at end of file diff --git a/code/studio/src/plugins/core/general_settings_page.h b/code/studio/src/plugins/core/general_settings_page.h new file mode 100644 index 000000000..66eacd189 --- /dev/null +++ b/code/studio/src/plugins/core/general_settings_page.h @@ -0,0 +1,74 @@ +// Object Viewer Qt - MMORPG Framework +// Copyright (C) 2010 Winch Gate Property Limited +// Copyright (C) 2011 Dzmitry Kamiahin +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + + +#ifndef GENERAL_SETTINGS_PAGE_H +#define GENERAL_SETTINGS_PAGE_H + +#include + +#include "ioptions_page.h" + +#include "ui_general_settings_page.h" + +class QWidget; + +namespace Core +{ +/** +@class GeneralSettingsPage +*/ +class GeneralSettingsPage : public Core::IOptionsPage +{ + Q_OBJECT + +public: + explicit GeneralSettingsPage(QObject *parent = 0); + ~GeneralSettingsPage(); + + QString id() const; + QString trName() const; + QString category() const; + QString trCategory() const; + QIcon categoryIcon() const; + QWidget *createPage(QWidget *parent); + + void apply(); + void finish(); + + void applyGeneralSettings(); + +private Q_SLOTS: + void changeLanguage(const QString &lang); + void setPluginsPath(); + void setLevelDesignPath(); + void setAssetsPath(); + void setPrimitivesPath(); + void setLigoConfigFile(); + +private: + void readSettings(); + void writeSettings(); + + QPalette m_originalPalette; + QWidget *m_page; + Ui::GeneralSettingsPage m_ui; +}; + +} // namespace Core + +#endif // GENERAL_SETTINGS_H diff --git a/code/studio/src/plugins/core/general_settings_page.ui b/code/studio/src/plugins/core/general_settings_page.ui new file mode 100644 index 000000000..7d40b65df --- /dev/null +++ b/code/studio/src/plugins/core/general_settings_page.ui @@ -0,0 +1,233 @@ + + + GeneralSettingsPage + + + + 0 + 0 + 267 + 282 + + + + Form + + + + 6 + + + 3 + + + + + Qt Style + + + + 6 + + + 6 + + + + + + default + + + + + + + + Use style's standard palette + + + + + + + + + + Language + + + + 6 + + + + + false + + + + English + + + + + German + + + + + French + + + + + Russian + + + + + + + + + + + Paths + + + + 6 + + + 6 + + + + + Plugins + + + + + + + + 0 + 0 + + + + + + + + ... + + + + + + + Sheets + + + + + + + + 0 + 0 + + + + + + + + ... + + + + + + + Assets Database: + + + + + + + + 0 + 0 + + + + + + + + ... + + + + + + + Primitives + + + + + + + + + + ... + + + + + + + + + + Ligo Config File + + + + + + + ... + + + + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + + + + diff --git a/code/studio/src/plugins/core/icons/ic_nel_add_item.png b/code/studio/src/plugins/core/icons/ic_nel_add_item.png new file mode 100644 index 0000000000000000000000000000000000000000..bde338f7851d2675b29272c7dcf9471196a8f6cc GIT binary patch literal 3270 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 Eg5p97)c^nh literal 0 HcmV?d00001 diff --git a/code/studio/src/plugins/core/icons/ic_nel_crash.png b/code/studio/src/plugins/core/icons/ic_nel_crash.png new file mode 100644 index 0000000000000000000000000000000000000000..5e1f6380bad86acca278838ce7a1c6499eb2660f GIT binary patch literal 6630 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 literal 0 HcmV?d00001 diff --git a/code/studio/src/plugins/core/icons/ic_nel_down_item.png b/code/studio/src/plugins/core/icons/ic_nel_down_item.png new file mode 100644 index 0000000000000000000000000000000000000000..fc86c4f6db072ec99ee76b81b8ea21d607226dd7 GIT binary patch literal 3812 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 literal 0 HcmV?d00001 diff --git a/code/studio/src/plugins/core/icons/ic_nel_open.png b/code/studio/src/plugins/core/icons/ic_nel_open.png new file mode 100644 index 0000000000000000000000000000000000000000..c4992affd19cf3a55bb8ec2f3121e5befa69a55c GIT binary patch literal 4310 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 rVX-&N2bPDNB8 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 UsoZjLV*mgE07*qoM6N<$g2^9G?f?J) literal 0 HcmV?d00001 diff --git a/code/studio/src/plugins/core/icons/ic_nel_save.png b/code/studio/src/plugins/core/icons/ic_nel_save.png new file mode 100644 index 0000000000000000000000000000000000000000..5aeb3bbe94a27c3528cecf0f2e849fb82a85b4b3 GIT binary patch literal 43738 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 %I{nv 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 literal 0 HcmV?d00001 diff --git a/code/studio/src/plugins/core/icons/ic_nel_save_as.png b/code/studio/src/plugins/core/icons/ic_nel_save_as.png new file mode 100644 index 0000000000000000000000000000000000000000..6cb71a33436e58801b73476821800b1b95a1018e GIT binary patch literal 52871 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 mw#_~9)Gt2qq5{#N!2bXMO`x+Fh$+(m0000 +// Copyright (C) 2010 Winch Gate Property Limited +// Copyright (C) 2011 Dzmitry Kamiahin +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +#ifndef ICONTEXT_H +#define ICONTEXT_H + +// Project includes +#include "core_global.h" + +// Qt includes +#include +#include +#include + +QT_BEGIN_NAMESPACE +class QWidget; +class QUndoStack; +QT_END_NAMESPACE + +namespace Core +{ +/** +@interface IContext +@brief The IContext is an interface for providing tab pages in main window. +@details You need to subclass this interface and put an instance of your subclass + into the plugin manager object pool. +*/ +class CORE_EXPORT IContext: public QObject +{ + Q_OBJECT +public: + IContext(QObject *parent = 0): QObject(parent) {} + virtual ~IContext() {} + + /// id() is a unique identifier for referencing this page + virtual QString id() const = 0; + + /// trName() is the (translated) name for display. + virtual QString trName() const = 0; + + /// icon() is the icon for display + virtual QIcon icon() const = 0; + + /// The widget will be destroyed by the widget hierarchy when the main window closes + virtual QWidget *widget() = 0; + + virtual QUndoStack *undoStack() = 0; + + virtual void open() = 0; + + virtual void save(){} + + virtual void saveAs(){} + + virtual void newDocument(){} + + virtual void close(){} +}; + +} // namespace Core + +#endif // ICONTEXT_H diff --git a/code/studio/src/plugins/core/icore.h b/code/studio/src/plugins/core/icore.h new file mode 100644 index 000000000..4f1ee474f --- /dev/null +++ b/code/studio/src/plugins/core/icore.h @@ -0,0 +1,70 @@ +// Object Viewer Qt - MMORPG Framework +// Copyright (C) 2010 Winch Gate Property Limited +// Copyright (C) 2011 Dzmitry Kamiahin +// Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +#ifndef ICORE_H +#define ICORE_H + +#include "core_global.h" + +#include + +QT_BEGIN_NAMESPACE +class QMainWindow; +class QSettings; +QT_END_NAMESPACE + +namespace ExtensionSystem +{ +class IPluginManager; +} + +namespace Core +{ +class MenuManager; +class ContextManager; + +class CORE_EXPORT ICore : public QObject +{ + Q_OBJECT + +public: + ICore() {} + virtual ~ICore() {} + + static ICore *instance(); + + virtual bool showOptionsDialog(const QString &group = QString(), + const QString &page = QString(), + QWidget *parent = 0) = 0; + + virtual MenuManager *menuManager() const = 0; + virtual ContextManager *contextManager() const = 0; + + virtual QSettings *settings() const = 0; + virtual QMainWindow *mainWindow() const = 0; + + virtual ExtensionSystem::IPluginManager *pluginManager() const = 0; + +Q_SIGNALS: + void changeSettings(); + void closeMainWindow(); +}; + +} // namespace Core + +#endif // ICORE_H diff --git a/code/studio/src/plugins/core/icore_listener.h b/code/studio/src/plugins/core/icore_listener.h new file mode 100644 index 000000000..c27e40242 --- /dev/null +++ b/code/studio/src/plugins/core/icore_listener.h @@ -0,0 +1,63 @@ +// Object Viewer Qt - MMORPG Framework +// Copyright (C) 2010 Winch Gate Property Limited +// Copyright (C) 2011 Dzmitry Kamiahin +// Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +#ifndef ICORE_LISTENER_H +#define ICORE_LISTENER_H + +// Project includes +#include "core_global.h" + +// Qt includes +#include + +QT_BEGIN_NAMESPACE +class QWidget; +QT_END_NAMESPACE + +namespace Core +{ +/** +@interface ICoreListener +@brief The ICoreListener is an interface for providing a hook for plugins to veto on close event emitted from +the core plugin. +@details You implement this interface if you want to prevent the closing of the whole application. +If the application window requests a close, then first ICoreListener::closeMainWindow() is called +(in arbitrary order) on all registered objects implementing this interface. +If one if these calls returns false, the process is aborted and the event is ignored. If all calls return +true, the corresponding signal is emitted and the event is accepted/performed. + +You need to add your implementing object to the plugin managers objects: +PluginManager->addObject(yourImplementingObject); +Don't forget to remove the object again at deconstruction (e.g. in the destructor of +your plugin) +*/ +class CORE_EXPORT ICoreListener: public QObject +{ + Q_OBJECT +public: + ICoreListener(QObject *parent = 0): QObject(parent) {} + virtual ~ICoreListener() {} + + /// Return false from the implemented method if you want to prevent the event. + virtual bool closeMainWindow() const = 0; +}; + +} // namespace Core + + +#endif // ICORE_LISTENER_H diff --git a/code/studio/src/plugins/core/images/nel.png b/code/studio/src/plugins/core/images/nel.png new file mode 100644 index 0000000000000000000000000000000000000000..d2139bb2557984f999a563059ea00f7e76436293 GIT binary patch literal 15587 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 literal 0 HcmV?d00001 diff --git a/code/studio/src/plugins/core/images/preferences.png b/code/studio/src/plugins/core/images/preferences.png new file mode 100644 index 0000000000000000000000000000000000000000..729bc039355928ae3b0c39969f6dbfea6154a125 GIT binary patch literal 10286 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 +// Copyright (C) 2010 Winch Gate Property Limited +// Copyright (C) 2011 Dzmitry Kamiahin +// Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +#ifndef IOPTIONS_PAGE_H +#define IOPTIONS_PAGE_H + +// Project includes +#include "core_global.h" + +// Qt includes +#include + +QT_BEGIN_NAMESPACE +class QWidget; +class QIcon; +QT_END_NAMESPACE + +namespace Core +{ +/** +@interface IOptionsPage +@brief The IOptionsPage is an interface for providing options pages. +@details You need to subclass this interface and put an instance of your subclass + into the plugin manager object pool. +*/ +class CORE_EXPORT IOptionsPage: public QObject +{ + Q_OBJECT +public: + IOptionsPage(QObject *parent = 0): QObject(parent) {} + virtual ~IOptionsPage() {} + + /// id() is a unique identifier for referencing this page + virtual QString id() const = 0; + + /// trName() is the (translated) name for display. + virtual QString trName() const = 0; + + /// category() is the unique id for the category that the page should be displayed in + virtual QString category() const = 0; + + /// trCategory() is the translated category + virtual QString trCategory() const = 0; + + virtual QIcon categoryIcon() const = 0; + + /// createPage() is called to retrieve the widget to show in the preferences dialog + /// The widget will be destroyed by the widget hierarchy when the dialog closes + virtual QWidget *createPage(QWidget *parent) = 0; + + /// apply() is called to store the settings. It should detect if any changes have been made and store those. + virtual void apply() = 0; + + /// finish() is called directly before the preferences dialog closes + virtual void finish() = 0; +}; + +} // namespace Core + +#endif // IOPTIONS_PAGE_H diff --git a/code/studio/src/plugins/core/main_window.cpp b/code/studio/src/plugins/core/main_window.cpp new file mode 100644 index 000000000..a90e67bc0 --- /dev/null +++ b/code/studio/src/plugins/core/main_window.cpp @@ -0,0 +1,492 @@ +// Object Viewer Qt - MMORPG Framework +// Copyright (C) 2010 Winch Gate Property Limited +// Copyright (C) 2011 Dzmitry Kamiahin +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +// Project includes +#include "main_window.h" +#include "icontext.h" +#include "icore_listener.h" +#include "menu_manager.h" +#include "context_manager.h" +#include "core.h" +#include "core_constants.h" +#include "settings_dialog.h" + +// NeL includes +#include + +// Qt includes +#include +#include +#include + +namespace Core +{ + +MainWindow::MainWindow(ExtensionSystem::IPluginManager *pluginManager, QWidget *parent) + : QMainWindow(parent), + m_pluginManager(0), + m_menuManager(0), + m_contextManager(0), + m_coreImpl(0), + m_lastDir("."), + m_undoGroup(0), + m_settings(0) +{ + QCoreApplication::setApplicationName(QLatin1String("ObjectViewerQt")); + QCoreApplication::setApplicationVersion(QLatin1String(Core::Constants::OVQT_VERSION_LONG)); + QCoreApplication::setOrganizationName(QLatin1String("RyzomCore")); + + setObjectName(Constants::MAIN_WINDOW); + setWindowIcon(QIcon(Constants::ICON_PILL)); + setWindowTitle(tr("Object Viewer Qt")); + + m_pluginManager = pluginManager; + m_settings = m_pluginManager->settings(); + m_coreImpl = new CoreImpl(this); + +#ifdef Q_WS_MAC + m_menuBar = new QMenuBar(0); +#else + m_menuBar = new QMenuBar(this); + setMenuBar(m_menuBar); +#endif + + m_menuManager = new MenuManager(m_menuBar, this); + + m_tabWidget = new QTabWidget(this); + m_tabWidget->setTabPosition(QTabWidget::South); + m_tabWidget->setMovable(false); + m_tabWidget->setDocumentMode(true); + setCentralWidget(m_tabWidget); + + m_contextManager = new ContextManager(this, m_tabWidget); + + setDockNestingEnabled(true); + m_originalPalette = QApplication::palette(); + m_undoGroup = new QUndoGroup(this); + + createDialogs(); + createActions(); + createMenus(); + createStatusBar(); + resize(1024, 768); +} + +MainWindow::~MainWindow() +{ + m_pluginManager->removeObject(m_coreImpl); + m_pluginManager->removeObject(m_menuManager); + + delete m_coreImpl; + m_coreImpl = 0; +} + +bool MainWindow::initialize(QString *errorString) +{ + Q_UNUSED(errorString); + m_pluginManager->addObject(m_coreImpl); + m_pluginManager->addObject(m_menuManager); + return true; +} + +void MainWindow::extensionsInitialized() +{ + readSettings(); + connect(m_contextManager, SIGNAL(currentContextChanged(Core::IContext *)), + this, SLOT(updateContext(Core::IContext *))); + if (m_contextManager->currentContext() != NULL) + updateContext(m_contextManager->currentContext()); + show(); +} + +MenuManager *MainWindow::menuManager() const +{ + return m_menuManager; +} + +ContextManager *MainWindow::contextManager() const +{ + return m_contextManager; +} + +QSettings *MainWindow::settings() const +{ + return m_settings; +} + +QUndoGroup *MainWindow::undoGroup() const +{ + return m_undoGroup; +} + +ExtensionSystem::IPluginManager *MainWindow::pluginManager() const +{ + return m_pluginManager; +} + +void MainWindow::addContextObject(IContext *context) +{ + QUndoStack *stack = context->undoStack(); + if (stack) + m_undoGroup->addStack(stack); +} + +void MainWindow::removeContextObject(IContext *context) +{ + QUndoStack *stack = context->undoStack(); + if (stack) + m_undoGroup->removeStack(stack); +} + +void MainWindow::open() +{ + m_contextManager->currentContext()->open(); +} + +void MainWindow::newFile() +{ + m_contextManager->currentContext()->newDocument(); +} + +void MainWindow::save() +{ + m_contextManager->currentContext()->save(); +} + +void MainWindow::saveAs() +{ + m_contextManager->currentContext()->saveAs(); +} + +void MainWindow::saveAll() +{ +} + +void MainWindow::closeDocument() +{ + m_contextManager->currentContext()->close(); +} + + +void MainWindow::cut() +{ +} + +void MainWindow::copy() +{ +} + +void MainWindow::paste() +{ +} + +void MainWindow::del() +{ +} + +void MainWindow::find() +{ +} + +void MainWindow::gotoPos() +{ +} + +void MainWindow::setFullScreen(bool enabled) +{ + if (bool(windowState() & Qt::WindowFullScreen) == enabled) + return; + if (enabled) + setWindowState(windowState() | Qt::WindowFullScreen); + else + setWindowState(windowState() & ~Qt::WindowFullScreen); +} + +bool MainWindow::showOptionsDialog(const QString &group, + const QString &page, + QWidget *parent) +{ + if (!parent) + parent = this; + SettingsDialog settingsDialog(m_pluginManager, group, page, parent); + settingsDialog.show(); + bool ok = settingsDialog.execDialog(); + if (ok) + Q_EMIT m_coreImpl->changeSettings(); + return ok; +} + +void MainWindow::about() +{ + QMessageBox::about(this, tr("About Object Viewer Qt"), + tr("

Object Viewer Qt

" + "

Ryzom Core team

Compiled on %1 %2").arg(__DATE__).arg(__TIME__)); +} + +void MainWindow::updateContext(Core::IContext *context) +{ + m_undoGroup->setActiveStack(context->undoStack()); +} + +void MainWindow::closeEvent(QCloseEvent *event) +{ + QList listeners = m_pluginManager->getObjects(); + Q_FOREACH(ICoreListener *listener, listeners) + { + if (!listener->closeMainWindow()) + { + event->ignore(); + return; + } + } + Q_EMIT m_coreImpl->closeMainWindow(); + + writeSettings(); + event->accept(); +} + +void MainWindow::createActions() +{ + m_newAction = new QAction(tr("&New"), this); + m_newAction->setIcon(QIcon(Constants::ICON_NEW)); + m_newAction->setShortcut(QKeySequence::New); + menuManager()->registerAction(m_newAction, Constants::NEW); + connect(m_newAction, SIGNAL(triggered()), this, SLOT(newFile())); + m_newAction->setEnabled(false); + + m_openAction = new QAction(tr("&Open..."), this); + m_openAction->setIcon(QIcon(Constants::ICON_OPEN)); + m_openAction->setShortcut(QKeySequence::Open); + m_openAction->setStatusTip(tr("Open an existing file")); + menuManager()->registerAction(m_openAction, Constants::OPEN); + connect(m_openAction, SIGNAL(triggered()), this, SLOT(open())); + + m_saveAction = new QAction(tr("&Save"), this); + m_saveAction->setIcon(QIcon(Constants::ICON_SAVE)); + m_saveAction->setShortcut(QKeySequence::Save); + menuManager()->registerAction(m_saveAction, Constants::SAVE); + connect(m_saveAction, SIGNAL(triggered()), this, SLOT(save())); + m_saveAction->setEnabled(false); + + m_saveAsAction = new QAction(tr("Save &As..."), this); + m_saveAsAction->setIcon(QIcon(Constants::ICON_SAVE_AS)); + m_saveAsAction->setShortcut(QKeySequence::SaveAs); + menuManager()->registerAction(m_saveAsAction, Constants::SAVE_AS); + connect(m_saveAsAction, SIGNAL(triggered()), this, SLOT(saveAs())); + m_saveAsAction->setEnabled(false); + + m_saveAllAction = new QAction(tr("&Save A&ll"), this); + m_saveAllAction->setShortcut(QKeySequence::SelectAll); + menuManager()->registerAction(m_saveAllAction, Constants::SAVE_ALL); + connect(m_saveAllAction, SIGNAL(triggered()), this, SLOT(saveAll())); + m_saveAllAction->setEnabled(false); + + m_closeAction = new QAction(tr("Close"), this); + m_closeAction->setShortcut(QKeySequence::Close); + menuManager()->registerAction(m_closeAction, Constants::CLOSE); + connect(m_closeAction, SIGNAL(triggered()), this, SLOT(closeDocument())); + m_closeAction->setEnabled(false); + + m_exitAction = new QAction(tr("E&xit"), this); + m_exitAction->setShortcut(QKeySequence(tr("Ctrl+Q"))); + m_exitAction->setStatusTip(tr("Exit the application")); + menuManager()->registerAction(m_exitAction, Constants::EXIT); + connect(m_exitAction, SIGNAL(triggered()), this, SLOT(close())); + + m_cutAction = new QAction(tr("Cu&t"), this); + m_cutAction->setShortcut(QKeySequence::Cut); + menuManager()->registerAction(m_cutAction, Constants::CUT); + connect(m_cutAction, SIGNAL(triggered()), this, SLOT(cut())); + m_cutAction->setEnabled(false); + + m_copyAction = new QAction(tr("&Copy"), this); + m_copyAction->setShortcut(QKeySequence::Copy); + menuManager()->registerAction(m_copyAction, Constants::COPY); + connect(m_copyAction, SIGNAL(triggered()), this, SLOT(copy())); + m_copyAction->setEnabled(false); + + m_pasteAction = new QAction(tr("&Paste"), this); + m_pasteAction->setShortcut(QKeySequence::Paste); + menuManager()->registerAction(m_pasteAction, Constants::PASTE); + connect(m_pasteAction, SIGNAL(triggered()), this, SLOT(paste())); + m_pasteAction->setEnabled(false); + + m_delAction = new QAction(tr("&Delete"), this); + m_delAction->setShortcut(QKeySequence::Delete); + menuManager()->registerAction(m_delAction, Constants::DEL); + connect(m_delAction, SIGNAL(triggered()), this, SLOT(del())); + m_delAction->setEnabled(false); + + m_selectAllAction = new QAction(tr("Select &All"), this); + m_selectAllAction->setShortcut(QKeySequence::SelectAll); + menuManager()->registerAction(m_selectAllAction, Constants::SELECT_ALL); + connect(m_selectAllAction, SIGNAL(triggered()), this, SLOT(selectAll())); + m_selectAllAction->setEnabled(false); + + m_findAction = new QAction(tr("&Find"), this); + m_findAction->setShortcut(QKeySequence::Find); + menuManager()->registerAction(m_findAction, Constants::FIND); + connect(m_findAction, SIGNAL(triggered()), this, SLOT(find())); + m_findAction->setEnabled(false); + + m_gotoAction = new QAction(tr("&Go To.."), this); + m_gotoAction->setShortcut(QKeySequence(tr("Ctrl+G"))); + menuManager()->registerAction(m_gotoAction, Constants::GOTO_POS); + connect(m_gotoAction, SIGNAL(triggered()), this, SLOT(gotoPos())); + m_gotoAction->setEnabled(false); + + m_fullscreenAction = new QAction(tr("Fullscreen"), this); + m_fullscreenAction->setCheckable(true); + m_fullscreenAction->setShortcut(QKeySequence(tr("Ctrl+Shift+F11"))); + menuManager()->registerAction(m_fullscreenAction, Constants::TOGGLE_FULLSCREEN); + connect(m_fullscreenAction, SIGNAL(triggered(bool)), this, SLOT(setFullScreen(bool))); + + m_settingsAction = new QAction(tr("&Settings"), this); + m_settingsAction->setIcon(QIcon(":/images/preferences.png")); + m_settingsAction->setShortcut(QKeySequence::Preferences); + m_settingsAction->setStatusTip(tr("Open the settings dialog")); + menuManager()->registerAction(m_settingsAction, Constants::SETTINGS); + connect(m_settingsAction, SIGNAL(triggered()), this, SLOT(showOptionsDialog())); + + m_aboutAction = new QAction(tr("&About"), this); + m_aboutAction->setStatusTip(tr("Show the application's About box")); + menuManager()->registerAction(m_aboutAction, Constants::ABOUT); + connect(m_aboutAction, SIGNAL(triggered()), this, SLOT(about())); + + m_aboutQtAction = new QAction(tr("About &Qt"), this); + m_aboutQtAction->setStatusTip(tr("Show the Qt library's About box")); + menuManager()->registerAction(m_aboutQtAction, Constants::ABOUT_QT); + connect(m_aboutQtAction, SIGNAL(triggered()), qApp, SLOT(aboutQt())); + + m_pluginViewAction = new QAction(tr("About &Plugins"), this); + m_pluginViewAction->setStatusTip(tr("Show the plugin view dialog")); + menuManager()->registerAction(m_pluginViewAction, Constants::ABOUT_PLUGINS); + connect(m_pluginViewAction, SIGNAL(triggered()), m_pluginView, SLOT(show())); + +#ifdef Q_WS_MAC + m_exitAction->setMenuRole(QAction::QuitRole); + m_settingsAction->setMenuRole(QAction::PreferencesRole); + m_aboutAction->setMenuRole(QAction::AboutRole); + m_aboutQtAction->setMenuRole(QAction::AboutQtRole); + m_pluginViewAction->setMenuRole(QAction::ApplicationSpecificRole); +#endif +} + +void MainWindow::createMenus() +{ + m_fileMenu = m_menuBar->addMenu(tr("&File")); + menuManager()->registerMenu(m_fileMenu, Constants::M_FILE); + m_fileMenu->addAction(m_newAction); + m_fileMenu->addAction(m_openAction); + m_fileMenu->addSeparator(); + m_fileMenu->addAction(m_saveAction); + m_fileMenu->addAction(m_saveAsAction); + m_fileMenu->addAction(m_saveAllAction); + m_fileMenu->addAction(m_closeAction); + m_fileMenu->addSeparator(); + + m_recentFilesMenu = m_fileMenu->addMenu(tr("Recent &Files")); + m_recentFilesMenu->setEnabled(false); + menuManager()->registerMenu(m_recentFilesMenu, Constants::M_FILE_RECENTFILES); + + m_fileMenu->addSeparator(); + m_fileMenu->addAction(m_exitAction); + + m_editMenu = m_menuBar->addMenu(tr("&Edit")); + QAction *undoAction = m_undoGroup->createUndoAction(this); + menuManager()->registerAction(undoAction, Constants::UNDO); + undoAction->setIcon(QIcon(Constants::ICON_UNDO)); + undoAction->setShortcut(QKeySequence::Undo); + QAction *redoAction = m_undoGroup->createRedoAction(this); + menuManager()->registerAction(redoAction, Constants::REDO); + redoAction->setIcon(QIcon(Constants::ICON_REDO)); + redoAction->setShortcut(QKeySequence::Redo); + m_editMenu->addAction(undoAction); + m_editMenu->addAction(redoAction); + + m_editMenu->addSeparator(); + m_editMenu->addAction(m_cutAction); + m_editMenu->addAction(m_copyAction); + m_editMenu->addAction(m_pasteAction); + m_editMenu->addAction(m_delAction); + m_editMenu->addSeparator(); + m_editMenu->addAction(m_selectAllAction); + m_editMenu->addSeparator(); + m_editMenu->addAction(m_findAction); + m_editMenu->addAction(m_gotoAction); + menuManager()->registerMenu(m_editMenu, Constants::M_EDIT); + + m_viewMenu = m_menuBar->addMenu(tr("&View")); + m_viewMenu->addAction(m_fullscreenAction); + m_viewMenu->addAction(m_dockWidget->toggleViewAction()); + menuManager()->registerMenu(m_viewMenu, Constants::M_VIEW); + + m_toolsMenu = m_menuBar->addMenu(tr("&Tools")); + menuManager()->registerMenu(m_toolsMenu, Constants::M_TOOLS); + + m_sheetMenu = m_toolsMenu->addMenu(tr("&Sheet")); + menuManager()->registerMenu(m_sheetMenu, Constants::M_SHEET); + +// m_toolsMenu->addSeparator(); + + m_toolsMenu->addAction(m_settingsAction); + + m_menuBar->addSeparator(); + + m_helpMenu = m_menuBar->addMenu(tr("&Help")); + menuManager()->registerMenu(m_helpMenu, Constants::M_HELP); + m_helpMenu->addAction(m_aboutAction); + m_helpMenu->addAction(m_aboutQtAction); + m_helpMenu->addAction(m_pluginViewAction); +} + +void MainWindow::createStatusBar() +{ + statusBar()->showMessage(tr("StatusReady")); +} + +void MainWindow::createDialogs() +{ + m_pluginView = new PluginView(m_pluginManager, this); + + // Create undo/redo command list + m_dockWidget = new QDockWidget("Command List", this); + m_dockWidget->setObjectName(QString::fromUtf8("UndoRedoCommandDockWidget")); + QUndoView *undoView = new QUndoView(m_undoGroup, m_dockWidget); + m_dockWidget->setWidget(undoView); + addDockWidget(Qt::RightDockWidgetArea, m_dockWidget); +} + +void MainWindow::readSettings() +{ + m_settings->beginGroup(Constants::MAIN_WINDOW_SECTION); + restoreState(m_settings->value(Constants::MAIN_WINDOW_STATE).toByteArray()); + restoreGeometry(m_settings->value(Constants::MAIN_WINDOW_GEOMETRY).toByteArray()); + m_settings->endGroup(); +} + +void MainWindow::writeSettings() +{ + m_settings->beginGroup(Constants::MAIN_WINDOW_SECTION); + m_settings->setValue(Constants::MAIN_WINDOW_STATE, saveState()); + m_settings->setValue(Constants::MAIN_WINDOW_GEOMETRY, saveGeometry()); + m_settings->endGroup(); +} + +} /* namespace Core */ + +/* end of file */ diff --git a/code/studio/src/plugins/core/main_window.h b/code/studio/src/plugins/core/main_window.h new file mode 100644 index 000000000..d258a5eba --- /dev/null +++ b/code/studio/src/plugins/core/main_window.h @@ -0,0 +1,147 @@ +// Object Viewer Qt - MMORPG Framework +// Copyright (C) 2010 Winch Gate Property Limited +// Copyright (C) 2011 Dzmitry Kamiahin +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +#ifndef MAIN_WINDOW_H +#define MAIN_WINDOW_H + +// Project includes +#include "../../extension_system/iplugin_manager.h" +#include "plugin_view_dialog.h" + +// STL includes + +// Qt includes +#include +#include +#include + +namespace Core +{ +class CSettingsDialog; +class CorePlugin; +class IContext; +class MenuManager; +class ContextManager; +class CoreImpl; + +class MainWindow : public QMainWindow +{ + Q_OBJECT + +public: + MainWindow(ExtensionSystem::IPluginManager *pluginManager, QWidget *parent = 0); + ~MainWindow(); + + bool initialize(QString *errorString); + void extensionsInitialized(); + + MenuManager *menuManager() const; + ContextManager *contextManager() const; + QSettings *settings() const; + QUndoGroup *undoGroup() const; + + ExtensionSystem::IPluginManager *pluginManager() const; + + void addContextObject(IContext *context); + void removeContextObject(IContext *context); + +public Q_SLOTS: + bool showOptionsDialog(const QString &group = QString(), + const QString &page = QString(), + QWidget *parent = 0); + void updateContext(Core::IContext *context); + +private Q_SLOTS: + void open(); + void newFile(); + void save(); + void saveAs(); + void saveAll(); + void closeDocument(); + void cut(); + void copy(); + void paste(); + void del(); + void find(); + void gotoPos(); + void setFullScreen(bool enabled); + void about(); + +protected: + virtual void closeEvent(QCloseEvent *event); + +private: + void createActions(); + void createMenus(); + void createStatusBar(); + void createDialogs(); + + void readSettings(); + void writeSettings(); + + ExtensionSystem::IPluginManager *m_pluginManager; + PluginView *m_pluginView; + MenuManager *m_menuManager; + ContextManager *m_contextManager; + CoreImpl *m_coreImpl; + + QPalette m_originalPalette; + QString m_lastDir; + + QDockWidget *m_dockWidget; + QUndoGroup *m_undoGroup; + QSettings *m_settings; + + QTimer *m_mainTimer; + QTimer *m_statusBarTimer; + + QTabWidget *m_tabWidget; + + QMenu *m_fileMenu; + QMenu *m_recentFilesMenu; + QMenu *m_editMenu; + QMenu *m_viewMenu; + QMenu *m_toolsMenu; + QMenu *m_helpMenu; + QMenuBar *m_menuBar; + QMenu *m_sheetMenu; + + QAction *m_newAction; + QAction *m_openAction; + QAction *m_saveAction; + QAction *m_saveAsAction; + QAction *m_saveAllAction; + QAction *m_closeAction; + QAction *m_exitAction; + QAction *m_cutAction; + QAction *m_copyAction; + QAction *m_pasteAction; + QAction *m_delAction; + QAction *m_selectAllAction; + QAction *m_findAction; + QAction *m_gotoAction; + QAction *m_fullscreenAction; + QAction *m_settingsAction; + QAction *m_pluginViewAction; + QAction *m_aboutAction; + QAction *m_aboutQtAction; + +};/* class MainWindow */ + +} /* namespace Core */ + +#endif // MAIN_WINDOW_H diff --git a/code/studio/src/plugins/core/menu_manager.cpp b/code/studio/src/plugins/core/menu_manager.cpp new file mode 100644 index 000000000..3e6272f0a --- /dev/null +++ b/code/studio/src/plugins/core/menu_manager.cpp @@ -0,0 +1,96 @@ +// Object Viewer Qt - MMORPG Framework +// Copyright (C) 2010 Winch Gate Property Limited +// Copyright (C) 2011 Dzmitry Kamiahin +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +// Project includes +#include "menu_manager.h" + +// NeL includes +#include + +namespace Core +{ +struct MenuManagerPrivate +{ + MenuManagerPrivate(): m_menuBar(0) {} + QMenuBar *m_menuBar; + typedef QHash IdMenuMap; + IdMenuMap m_menuMap; + typedef QHash IdActionMap; + IdActionMap m_actionMap; +}; + +MenuManager::MenuManager(QMenuBar *menuBar, QObject *parent) + : QObject(parent), + d(new MenuManagerPrivate()) +{ + d->m_menuBar = menuBar; +} + +MenuManager::~MenuManager() +{ + d->m_menuMap.clear(); + delete d; +} + +void MenuManager::registerMenu(QMenu *menu, const QString &id) +{ + menu->setObjectName(id); + d->m_menuMap.insert(id, menu); +} + +void MenuManager::registerAction(QAction *action, const QString &id) +{ + action->setObjectName(id); + d->m_actionMap.insert(id, action); +} + +QMenu *MenuManager::menu(const QString &id) const +{ + QMenu *result = 0; + if (!d->m_menuMap.contains(id)) + nlwarning("QMenu %s not found", id.toUtf8().constData()); + else + result = d->m_menuMap.value(id); + return result; +} + +QAction *MenuManager::action(const QString &id) const +{ + QAction *result = 0; + if (!d->m_actionMap.contains(id)) + nlwarning("QAction %s not found", id.toUtf8().constData()); + else + result = d->m_actionMap.value(id); + return result; +} + +void MenuManager::unregisterMenu(const QString &id) +{ + d->m_menuMap.remove(id); +} + +void MenuManager::unregisterAction(const QString &id) +{ + d->m_actionMap.remove(id); +} + +QMenuBar *MenuManager::menuBar() const +{ + return d->m_menuBar; +} + +} /* namespace Core */ \ No newline at end of file diff --git a/code/studio/src/plugins/core/menu_manager.h b/code/studio/src/plugins/core/menu_manager.h new file mode 100644 index 000000000..fd6af8f3a --- /dev/null +++ b/code/studio/src/plugins/core/menu_manager.h @@ -0,0 +1,67 @@ +// Object Viewer Qt - MMORPG Framework +// Copyright (C) 2010 Winch Gate Property Limited +// Copyright (C) 2011 Dzmitry Kamiahin +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +#ifndef MENU_MANAGER_H +#define MENU_MANAGER_H + +// Project includes +#include "core_global.h" + +// Qt includes +#include +#include +#include +#include +#include +#include + +namespace Core +{ +struct MenuManagerPrivate; + +/* +@interface MenuManager +@brief The MenuManager provide the interface for registration of menus and menu item. +@details The MenuManager provides centralized access to menus and menu items. +All menus and menu items should be registered in the MenuManager. +*/ +class CORE_EXPORT MenuManager: public QObject +{ + Q_OBJECT + +public: + MenuManager(QMenuBar *menuBar, QObject *parent = 0); + virtual ~MenuManager(); + + void registerMenu(QMenu *menu, const QString &id); + void registerAction(QAction *action, const QString &id); + + QMenu *menu(const QString &id) const; + QAction *action(const QString &id) const; + + void unregisterMenu(const QString &id); + void unregisterAction(const QString &id); + + QMenuBar *menuBar() const; +private: + + MenuManagerPrivate *d; +}; + +} // namespace Core + +#endif // MENU_MANAGER_H diff --git a/code/studio/src/plugins/core/ovqt_plugin_core.xml b/code/studio/src/plugins/core/ovqt_plugin_core.xml new file mode 100644 index 000000000..2f5d6e9a8 --- /dev/null +++ b/code/studio/src/plugins/core/ovqt_plugin_core.xml @@ -0,0 +1,7 @@ + + ovqt_plugin_core + Core + 0.8 + Ryzom Core + Core plugin. + \ No newline at end of file diff --git a/code/studio/src/plugins/core/plugin_view_dialog.cpp b/code/studio/src/plugins/core/plugin_view_dialog.cpp new file mode 100644 index 000000000..175902d39 --- /dev/null +++ b/code/studio/src/plugins/core/plugin_view_dialog.cpp @@ -0,0 +1,108 @@ +// Object Viewer Qt - MMORPG Framework +// Copyright (C) 2010 Winch Gate Property Limited +// Copyright (C) 2011 Dzmitry Kamiahin +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +#include "plugin_view_dialog.h" +#include "core_constants.h" + +#include "nel/misc/debug.h" + +// Qt includes +#include +#include +#include +#include + +// Project includes +#include "../../extension_system/iplugin_spec.h" +#include "../../extension_system/iplugin_manager.h" + +namespace Core +{ + +PluginView::PluginView(ExtensionSystem::IPluginManager *pluginManager, QWidget *parent) + : QDialog(parent), + m_checkStateColumn(0) +{ + m_ui.setupUi(this); + m_pluginManager = pluginManager; + + connect(m_pluginManager, SIGNAL(pluginsChanged()), this, SLOT(updateList())); + connect(this, SIGNAL(accepted()), this, SLOT(updateSettings())); + + // WhiteList is list of plugins which can not disable. + m_whiteList << Constants::OVQT_CORE_PLUGIN; + updateList(); +} + +PluginView::~PluginView() +{ +} + +void PluginView::updateList() +{ + static QIcon okIcon = QApplication::style()->standardIcon(QStyle::SP_DialogApplyButton); + static QIcon errorIcon = QApplication::style()->standardIcon(QStyle::SP_DialogCancelButton); + static QIcon notLoadedIcon = QApplication::style()->standardIcon(QStyle::SP_DialogResetButton); + + m_specToItem.clear(); + + QList items; + Q_FOREACH (ExtensionSystem::IPluginSpec *spec, m_pluginManager->plugins()) + { + QTreeWidgetItem *item = new QTreeWidgetItem(QStringList() + << spec->name() + << QString("%1").arg(spec->version()) + << spec->vendor() + << QDir::toNativeSeparators(spec->filePath())); + + bool ok = !spec->hasError(); + QIcon icon = ok ? okIcon : errorIcon; + if (ok && (spec->state() != ExtensionSystem::State::Running)) + icon = notLoadedIcon; + + item->setIcon(m_checkStateColumn, icon); + + if (!m_whiteList.contains(spec->name())) + item->setCheckState(m_checkStateColumn, spec->isEnabled() ? Qt::Checked : Qt::Unchecked); + + items.append(item); + m_specToItem.insert(spec, item); + } + + m_ui.pluginTreeWidget->clear(); + if (!items.isEmpty()) + m_ui.pluginTreeWidget->addTopLevelItems(items); + + m_ui.pluginTreeWidget->resizeColumnToContents(m_checkStateColumn); +} + +void PluginView::updateSettings() +{ + Q_FOREACH (ExtensionSystem::IPluginSpec *spec, m_pluginManager->plugins()) + { + if (m_specToItem.contains(spec) && (!m_whiteList.contains(spec->name()))) + { + QTreeWidgetItem *item = m_specToItem.value(spec); + if (item->checkState(m_checkStateColumn) == Qt::Checked) + spec->setEnabled(true); + else + spec->setEnabled(false); + } + } +} + +} /* namespace Core */ \ No newline at end of file diff --git a/code/studio/src/plugins/core/plugin_view_dialog.h b/code/studio/src/plugins/core/plugin_view_dialog.h new file mode 100644 index 000000000..aae16749d --- /dev/null +++ b/code/studio/src/plugins/core/plugin_view_dialog.h @@ -0,0 +1,58 @@ +// Object Viewer Qt - MMORPG Framework +// Copyright (C) 2010 Winch Gate Property Limited +// Copyright (C) 2011 Dzmitry Kamiahin +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +#ifndef PLUGIN_VIEW_H +#define PLUGIN_VIEW_H + +#include "ui_plugin_view_dialog.h" + +#include +#include + +namespace ExtensionSystem +{ +class IPluginManager; +class IPluginSpec; +} + +namespace Core +{ + +class PluginView: public QDialog +{ + Q_OBJECT + +public: + PluginView(ExtensionSystem::IPluginManager *pluginManager, QWidget *parent = 0); + ~PluginView(); + +private Q_SLOTS: + void updateList(); + void updateSettings(); + +private: + + const int m_checkStateColumn; + QMap m_specToItem; + QStringList m_whiteList; + ExtensionSystem::IPluginManager *m_pluginManager; + Ui::PluginView m_ui; +}; /* class PluginView */ + +} /* namespace Core */ + +#endif // PLUGIN_VIEW_H diff --git a/code/studio/src/plugins/core/plugin_view_dialog.ui b/code/studio/src/plugins/core/plugin_view_dialog.ui new file mode 100644 index 000000000..9d7d395be --- /dev/null +++ b/code/studio/src/plugins/core/plugin_view_dialog.ui @@ -0,0 +1,135 @@ + + + PluginView + + + + 0 + 0 + 756 + 296 + + + + About plugins + + + true + + + + + + true + + + 0 + + + false + + + true + + + false + + + true + + + + Name + + + + + Version + + + + + Vendor + + + + + Location + + + + + + + + false + + + Details + + + + + + + false + + + Error details + + + + + + + Qt::Horizontal + + + + 427 + 20 + + + + + + + + Close + + + + + + + false + + + All objects list + + + + + + + + + + + closePushButton + clicked() + PluginView + accept() + + + 620 + 232 + + + 507 + 226 + + + + + diff --git a/code/studio/src/plugins/core/qtwin.cpp b/code/studio/src/plugins/core/qtwin.cpp new file mode 100644 index 000000000..115203ded --- /dev/null +++ b/code/studio/src/plugins/core/qtwin.cpp @@ -0,0 +1,241 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** +** Use, modification and distribution is allowed without limitation, +** warranty, liability or support of any kind. +** +****************************************************************************/ + +#include "qtwin.h" +#include +#include +#include +#include +#include + +#ifdef Q_WS_WIN + +#include + +// Blur behind data structures +#define DWM_BB_ENABLE 0x00000001 // fEnable has been specified +#define DWM_BB_BLURREGION 0x00000002 // hRgnBlur has been specified +#define DWM_BB_TRANSITIONONMAXIMIZED 0x00000004 // fTransitionOnMaximized has been specified +#define WM_DWMCOMPOSITIONCHANGED 0x031E // Composition changed window message + +typedef struct _DWM_BLURBEHIND +{ + DWORD dwFlags; + BOOL fEnable; + HRGN hRgnBlur; + BOOL fTransitionOnMaximized; +} DWM_BLURBEHIND, *PDWM_BLURBEHIND; + +typedef struct _MARGINS +{ + int cxLeftWidth; + int cxRightWidth; + int cyTopHeight; + int cyBottomHeight; +} MARGINS, *PMARGINS; + +typedef HRESULT (WINAPI *PtrDwmIsCompositionEnabled)(BOOL *pfEnabled); +typedef HRESULT (WINAPI *PtrDwmExtendFrameIntoClientArea)(HWND hWnd, const MARGINS *pMarInset); +typedef HRESULT (WINAPI *PtrDwmEnableBlurBehindWindow)(HWND hWnd, const DWM_BLURBEHIND *pBlurBehind); +typedef HRESULT (WINAPI *PtrDwmGetColorizationColor)(DWORD *pcrColorization, BOOL *pfOpaqueBlend); + +static PtrDwmIsCompositionEnabled pDwmIsCompositionEnabled= 0; +static PtrDwmEnableBlurBehindWindow pDwmEnableBlurBehindWindow = 0; +static PtrDwmExtendFrameIntoClientArea pDwmExtendFrameIntoClientArea = 0; +static PtrDwmGetColorizationColor pDwmGetColorizationColor = 0; + + +/* + * Internal helper class that notifies windows if the + * DWM compositing state changes and updates the widget + * flags correspondingly. + */ +class WindowNotifier : public QWidget +{ +public: + WindowNotifier() + { + winId(); + } + void addWidget(QWidget *widget) + { + widgets.append(widget); + } + void removeWidget(QWidget *widget) + { + widgets.removeAll(widget); + } + bool winEvent(MSG *message, long *result); + +private: + QWidgetList widgets; +}; + +static bool resolveLibs() +{ + if (!pDwmIsCompositionEnabled) + { + QLibrary dwmLib(QString::fromAscii("dwmapi")); + pDwmIsCompositionEnabled =(PtrDwmIsCompositionEnabled)dwmLib.resolve("DwmIsCompositionEnabled"); + pDwmExtendFrameIntoClientArea = (PtrDwmExtendFrameIntoClientArea)dwmLib.resolve("DwmExtendFrameIntoClientArea"); + pDwmEnableBlurBehindWindow = (PtrDwmEnableBlurBehindWindow)dwmLib.resolve("DwmEnableBlurBehindWindow"); + pDwmGetColorizationColor = (PtrDwmGetColorizationColor)dwmLib.resolve("DwmGetColorizationColor"); + } + return pDwmIsCompositionEnabled != 0; +} + +#endif + +/*! + * Chekcs and returns true if Windows DWM composition + * is currently enabled on the system. + * + * To get live notification on the availability of + * this feature, you will currently have to + * reimplement winEvent() on your widget and listen + * for the WM_DWMCOMPOSITIONCHANGED event to occur. + * + */ +bool QtWin::isCompositionEnabled() +{ +#ifdef Q_WS_WIN + if (resolveLibs()) + { + HRESULT hr = S_OK; + BOOL isEnabled = false; + hr = pDwmIsCompositionEnabled(&isEnabled); + if (SUCCEEDED(hr)) + return isEnabled; + } +#endif + return false; +} + +/*! + * Enables Blur behind on a Widget. + * + * \a enable tells if the blur should be enabled or not + */ +bool QtWin::enableBlurBehindWindow(QWidget *widget, bool enable) +{ + Q_ASSERT(widget); + bool result = false; +#ifdef Q_WS_WIN + if (resolveLibs()) + { + DWM_BLURBEHIND bb = {0}; + HRESULT hr = S_OK; + bb.fEnable = enable; + bb.dwFlags = DWM_BB_ENABLE; + bb.hRgnBlur = NULL; + widget->setAttribute(Qt::WA_TranslucentBackground, enable); + widget->setAttribute(Qt::WA_NoSystemBackground, enable); + hr = pDwmEnableBlurBehindWindow(widget->winId(), &bb); + if (SUCCEEDED(hr)) + { + result = true; + windowNotifier()->addWidget(widget); + } + } +#endif + return result; +} + +/*! + * ExtendFrameIntoClientArea. + * + * This controls the rendering of the frame inside the window. + * Note that passing margins of -1 (the default value) will completely + * remove the frame from the window. + * + * \note you should not call enableBlurBehindWindow before calling + * this functions + * + * \a enable tells if the blur should be enabled or not + */ +bool QtWin::extendFrameIntoClientArea(QWidget *widget, int left, int top, int right, int bottom) +{ + + Q_ASSERT(widget); + Q_UNUSED(left); + Q_UNUSED(top); + Q_UNUSED(right); + Q_UNUSED(bottom); + + bool result = false; +#ifdef Q_WS_WIN + if (resolveLibs()) + { + QLibrary dwmLib(QString::fromAscii("dwmapi")); + HRESULT hr = S_OK; + MARGINS m = {left, top, right, bottom}; + hr = pDwmExtendFrameIntoClientArea(widget->winId(), &m); + if (SUCCEEDED(hr)) + { + result = true; + windowNotifier()->addWidget(widget); + } + widget->setAttribute(Qt::WA_TranslucentBackground, result); + } +#endif + return result; +} + +/*! + * Returns the current colorizationColor for the window. + * + * \a enable tells if the blur should be enabled or not + */ +QColor QtWin::colorizatinColor() +{ + QColor resultColor = QApplication::palette().window().color(); + +#ifdef Q_WS_WIN + if (resolveLibs()) + { + DWORD color = 0; + BOOL opaque = FALSE; + QLibrary dwmLib(QString::fromAscii("dwmapi")); + HRESULT hr = S_OK; + hr = pDwmGetColorizationColor(&color, &opaque); + if (SUCCEEDED(hr)) + resultColor = QColor(color); + } +#endif + return resultColor; +} + +#ifdef Q_WS_WIN +WindowNotifier *QtWin::windowNotifier() +{ + static WindowNotifier *windowNotifierInstance = 0; + if (!windowNotifierInstance) + windowNotifierInstance = new WindowNotifier; + return windowNotifierInstance; +} + + +/* Notify all enabled windows that the DWM state changed */ +bool WindowNotifier::winEvent(MSG *message, long *result) +{ + if (message && message->message == WM_DWMCOMPOSITIONCHANGED) + { + bool compositionEnabled = QtWin::isCompositionEnabled(); + Q_FOREACH(QWidget * widget, widgets) + { + if (widget) + { + widget->setAttribute(Qt::WA_NoSystemBackground, compositionEnabled); + } + widget->update(); + } + } + return QWidget::winEvent(message, result); +} +#endif diff --git a/code/studio/src/plugins/core/qtwin.h b/code/studio/src/plugins/core/qtwin.h new file mode 100644 index 000000000..5692a34fb --- /dev/null +++ b/code/studio/src/plugins/core/qtwin.h @@ -0,0 +1,37 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** +** Use, modification and distribution is allowed without limitation, +** warranty, liability or support of any kind. +** +****************************************************************************/ + +#ifndef QTWIN_H +#define QTWIN_H + +#include +#include +/** + * This is a helper class for using the Desktop Window Manager + * functionality on Windows 7 and Windows Vista. On other platforms + * these functions will simply not do anything. + */ + +class WindowNotifier; + +class QtWin +{ +public: + static bool enableBlurBehindWindow(QWidget *widget, bool enable = true); + static bool extendFrameIntoClientArea(QWidget *widget, + int left = -1, int top = -1, + int right = -1, int bottom = -1); + static bool isCompositionEnabled(); + static QColor colorizatinColor(); + +private: + static WindowNotifier *windowNotifier(); +}; + +#endif // QTWIN_H diff --git a/code/studio/src/plugins/core/search_paths_settings_page.cpp b/code/studio/src/plugins/core/search_paths_settings_page.cpp new file mode 100644 index 000000000..e76d6c796 --- /dev/null +++ b/code/studio/src/plugins/core/search_paths_settings_page.cpp @@ -0,0 +1,219 @@ +// Object Viewer Qt - MMORPG Framework +// Copyright (C) 2010 Winch Gate Property Limited +// Copyright (C) 2011 Dzmitry Kamiahin +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +// Project includes +#include "search_paths_settings_page.h" +#include "core_constants.h" +#include "icore.h" + +// NeL includes +#include + +// Qt includes +#include +#include +#include + +namespace Core +{ + +QString lastDir = "."; + +SearchPathsSettingsPage::SearchPathsSettingsPage(bool recurse, QObject *parent) + : IOptionsPage(parent), + m_recurse(recurse), + m_page(0) +{ +} + +SearchPathsSettingsPage::~SearchPathsSettingsPage() +{ +} + +QString SearchPathsSettingsPage::id() const +{ + if (m_recurse) + return QLatin1String("search_recurse_paths"); + else + return QLatin1String("search_paths"); +} + +QString SearchPathsSettingsPage::trName() const +{ + if (m_recurse) + return tr("Search Recurse Paths"); + else + return tr("Search Paths"); +} + +QString SearchPathsSettingsPage::category() const +{ + return QLatin1String(Constants::SETTINGS_CATEGORY_GENERAL); +} + +QString SearchPathsSettingsPage::trCategory() const +{ + return tr(Constants::SETTINGS_TR_CATEGORY_GENERAL); +} + +QIcon SearchPathsSettingsPage::categoryIcon() const +{ + return QIcon(); +} + +QWidget *SearchPathsSettingsPage::createPage(QWidget *parent) +{ + m_page = new QWidget(parent); + m_ui.setupUi(m_page); + + readSettings(); + checkEnabledButton(); + connect(m_ui.addToolButton, SIGNAL(clicked()), this, SLOT(addPath())); + connect(m_ui.removeToolButton, SIGNAL(clicked()), this, SLOT(delPath())); + connect(m_ui.upToolButton, SIGNAL(clicked()), this, SLOT(upPath())); + connect(m_ui.downToolButton, SIGNAL(clicked()), this, SLOT(downPath())); + connect(m_ui.resetToolButton, SIGNAL(clicked()), m_ui.pathsListWidget, SLOT(clear())); + return m_page; +} + +void SearchPathsSettingsPage::apply() +{ + writeSettings(); + applySearchPaths(); +} + +void SearchPathsSettingsPage::finish() +{ + delete m_page; + m_page = 0; +} + +void SearchPathsSettingsPage::applySearchPaths() +{ + QStringList paths, remapExt; + QSettings *settings = Core::ICore::instance()->settings(); + settings->beginGroup(Core::Constants::DATA_PATH_SECTION); + if (m_recurse) + paths = settings->value(Core::Constants::RECURSIVE_SEARCH_PATHS).toStringList(); + else + paths = settings->value(Core::Constants::SEARCH_PATHS).toStringList(); + + remapExt = settings->value(Core::Constants::REMAP_EXTENSIONS).toStringList(); + settings->endGroup(); + + for (int i = 1; i < remapExt.size(); i += 2) + NLMISC::CPath::remapExtension(remapExt.at(i - 1).toUtf8().constData(), remapExt.at(i).toUtf8().constData(), true); + + Q_FOREACH(QString path, paths) + { + NLMISC::CPath::addSearchPath(path.toUtf8().constData(), m_recurse, false); + } +} + +void SearchPathsSettingsPage::addPath() +{ + QString newPath = QFileDialog::getExistingDirectory(m_page, "", lastDir); + if (!newPath.isEmpty()) + { + QListWidgetItem *newItem = new QListWidgetItem; + newItem->setText(newPath); + newItem->setFlags(Qt::ItemIsEditable | Qt::ItemIsEnabled | Qt::ItemIsSelectable); + m_ui.pathsListWidget->addItem(newItem); + lastDir = newPath; + } + + checkEnabledButton(); +} + +void SearchPathsSettingsPage::delPath() +{ + QListWidgetItem *removeItem = m_ui.pathsListWidget->takeItem(m_ui.pathsListWidget->currentRow()); + if (!removeItem) + delete removeItem; + + checkEnabledButton(); +} + +void SearchPathsSettingsPage::upPath() +{ + int currentRow = m_ui.pathsListWidget->currentRow(); + if (!(currentRow == 0)) + { + QListWidgetItem *item = m_ui.pathsListWidget->takeItem(currentRow); + m_ui.pathsListWidget->insertItem(--currentRow, item); + m_ui.pathsListWidget->setCurrentRow(currentRow); + } +} + +void SearchPathsSettingsPage::downPath() +{ + int currentRow = m_ui.pathsListWidget->currentRow(); + if (!(currentRow == m_ui.pathsListWidget->count()-1)) + { + QListWidgetItem *item = m_ui.pathsListWidget->takeItem(currentRow); + m_ui.pathsListWidget->insertItem(++currentRow, item); + m_ui.pathsListWidget->setCurrentRow(currentRow); + } +} + +void SearchPathsSettingsPage::readSettings() +{ + QStringList paths; + QSettings *settings = Core::ICore::instance()->settings(); + settings->beginGroup(Core::Constants::DATA_PATH_SECTION); + if (m_recurse) + paths = settings->value(Core::Constants::RECURSIVE_SEARCH_PATHS).toStringList(); + else + paths = settings->value(Core::Constants::SEARCH_PATHS).toStringList(); + settings->endGroup(); + Q_FOREACH(QString path, paths) + { + QListWidgetItem *newItem = new QListWidgetItem; + newItem->setText(path); + newItem->setFlags(Qt::ItemIsEditable | Qt::ItemIsEnabled | Qt::ItemIsSelectable); + m_ui.pathsListWidget->addItem(newItem); + } +} + +void SearchPathsSettingsPage::writeSettings() +{ + QStringList paths; + for (int i = 0; i < m_ui.pathsListWidget->count(); ++i) + paths << m_ui.pathsListWidget->item(i)->text(); + + QSettings *settings = Core::ICore::instance()->settings(); + settings->beginGroup(Core::Constants::DATA_PATH_SECTION); + if (m_recurse) + settings->setValue(Core::Constants::RECURSIVE_SEARCH_PATHS, paths); + else + settings->setValue(Core::Constants::SEARCH_PATHS, paths); + settings->endGroup(); + settings->sync(); +} + +void SearchPathsSettingsPage::checkEnabledButton() +{ + bool bEnabled = true; + if (m_ui.pathsListWidget->count() == 0) + bEnabled = false; + + m_ui.removeToolButton->setEnabled(bEnabled); + m_ui.upToolButton->setEnabled(bEnabled); + m_ui.downToolButton->setEnabled(bEnabled); +} + +} /* namespace Core */ \ No newline at end of file diff --git a/code/studio/src/plugins/core/search_paths_settings_page.h b/code/studio/src/plugins/core/search_paths_settings_page.h new file mode 100644 index 000000000..c45b29571 --- /dev/null +++ b/code/studio/src/plugins/core/search_paths_settings_page.h @@ -0,0 +1,74 @@ +// Object Viewer Qt - MMORPG Framework +// Copyright (C) 2010 Winch Gate Property Limited +// Copyright (C) 2011 Dzmitry Kamiahin +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + + +#ifndef SEARCH_PATHS_SETTINGS_PAGE_H +#define SEARCH_PATHS_SETTINGS_PAGE_H + +#include + +#include "ioptions_page.h" + +#include "ui_search_paths_settings_page.h" + +class QWidget; + +namespace Core +{ +/** +@class SearchPathsSettingsPage +*/ +class SearchPathsSettingsPage : public Core::IOptionsPage +{ + Q_OBJECT + +public: + explicit SearchPathsSettingsPage(bool recurse, QObject *parent = 0); + ~SearchPathsSettingsPage(); + + QString id() const; + QString trName() const; + QString category() const; + QString trCategory() const; + QIcon categoryIcon() const; + QWidget *createPage(QWidget *parent); + + void apply(); + void finish(); + + // Set of the search paths(not recursive) and the remap extensions (loading from settings file) + void applySearchPaths(); + +private Q_SLOTS: + void addPath(); + void delPath(); + void upPath(); + void downPath(); + +private: + void readSettings(); + void writeSettings(); + void checkEnabledButton(); + + bool m_recurse; + QWidget *m_page; + Ui::SearchPathsSettingsPage m_ui; +}; + +} // namespace Core + +#endif // SEARCH_PATHS_SETTINGS_H diff --git a/code/studio/src/plugins/core/search_paths_settings_page.ui b/code/studio/src/plugins/core/search_paths_settings_page.ui new file mode 100644 index 000000000..cf47314b8 --- /dev/null +++ b/code/studio/src/plugins/core/search_paths_settings_page.ui @@ -0,0 +1,198 @@ + + + SearchPathsSettingsPage + + + + 0 + 0 + 431 + 285 + + + + Form + + + + 6 + + + 3 + + + + + Search paths + + + + + + + Qt::Horizontal + + + + 228 + 20 + + + + + + + + 3 + + + + + + 0 + 0 + + + + Add + + + + + + + :/core/icons/ic_nel_add_item.png:/core/icons/ic_nel_add_item.png + + + + 20 + 20 + + + + true + + + + + + + + 0 + 0 + + + + Delete + + + + + + + :/core/icons/ic_nel_delete_item.png:/core/icons/ic_nel_delete_item.png + + + + 20 + 20 + + + + true + + + + + + + + 0 + 0 + + + + Up + + + + + + + :/core/icons/ic_nel_up_item.png:/core/icons/ic_nel_up_item.png + + + + 20 + 20 + + + + true + + + + + + + + 0 + 0 + + + + Down + + + + + + + :/core/icons/ic_nel_down_item.png:/core/icons/ic_nel_down_item.png + + + + 20 + 20 + + + + true + + + + + + + Reset + + + + + + + :/core/icons/ic_nel_reset_all.png:/core/icons/ic_nel_reset_all.png + + + + 20 + 20 + + + + true + + + + + + + + + + + + + + + diff --git a/code/studio/src/plugins/core/settings_dialog.cpp b/code/studio/src/plugins/core/settings_dialog.cpp new file mode 100644 index 000000000..4b7bbac3a --- /dev/null +++ b/code/studio/src/plugins/core/settings_dialog.cpp @@ -0,0 +1,182 @@ +// Object Viewer Qt - MMORPG Framework +// Copyright (C) 2010 Winch Gate Property Limited +// Copyright (C) 2011 Dzmitry Kamiahin +// Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +// Project includes +#include "settings_dialog.h" +#include "ioptions_page.h" + +// Qt includes +#include +#include + +struct PageData +{ + int index; + QString category; + QString id; +}; + +Q_DECLARE_METATYPE(PageData); + +namespace Core +{ +SettingsDialog::SettingsDialog(ExtensionSystem::IPluginManager *pluginManager, + const QString &categoryId, + const QString &pageId, + QWidget *parent) + : QDialog(parent), + m_applied(false) +{ + m_ui.setupUi(this); + + m_plugMan = pluginManager; + + QString initialCategory = categoryId; + QString initialPage = pageId; + + m_ui.buttonBox->button(QDialogButtonBox::Ok)->setDefault(true); + + connect(m_ui.buttonBox->button(QDialogButtonBox::Apply), SIGNAL(clicked()), this, SLOT(apply())); + + m_ui.splitter->setCollapsible(1, false); + m_ui.pageTree->header()->setVisible(false); + + connect(m_ui.pageTree, SIGNAL(currentItemChanged(QTreeWidgetItem *, QTreeWidgetItem *)), + this, SLOT(pageSelected())); + + QMap categories; + + QList pages = m_plugMan->getObjects(); + + int index = 0; + Q_FOREACH(IOptionsPage *page, pages) + { + PageData pageData; + pageData.index = index; + pageData.category = page->category(); + pageData.id = page->id(); + + QTreeWidgetItem *item = new QTreeWidgetItem; + item->setText(0, page->trName()); + item->setData(0, Qt::UserRole, qVariantFromValue(pageData)); + + QStringList categoriesId = page->category().split(QLatin1Char('|')); + QStringList trCategories = page->trCategory().split(QLatin1Char('|')); + QString currentCategory = categoriesId.at(0); + + QTreeWidgetItem *treeitem; + if (!categories.contains(currentCategory)) + { + treeitem = new QTreeWidgetItem(m_ui.pageTree); + treeitem->setText(0, trCategories.at(0)); + treeitem->setData(0, Qt::UserRole, qVariantFromValue(pageData)); + categories.insert(currentCategory, treeitem); + } + + int catCount = 1; + while (catCount < categoriesId.count()) + { + if (!categories.contains(currentCategory + QLatin1Char('|') + categoriesId.at(catCount))) + { + treeitem = new QTreeWidgetItem(categories.value(currentCategory)); + currentCategory += QLatin1Char('|') + categoriesId.at(catCount); + treeitem->setText(0, trCategories.at(catCount)); + treeitem->setData(0, Qt::UserRole, qVariantFromValue(pageData)); + categories.insert(currentCategory, treeitem); + } + else + { + currentCategory += QLatin1Char('|') + categoriesId.at(catCount); + } + ++catCount; + } + + categories.value(currentCategory)->addChild(item); + + m_pages.append(page); + m_ui.stackedPages->addWidget(page->createPage(m_ui.stackedPages)); + + if (page->id() == initialPage && currentCategory == initialCategory) + { + m_ui.stackedPages->setCurrentIndex(m_ui.stackedPages->count()); + m_ui.pageTree->setCurrentItem(item); + } + + index++; + } + + QList sizes; + sizes << 150 << 300; + m_ui.splitter->setSizes(sizes); + + m_ui.splitter->setStretchFactor(m_ui.splitter->indexOf(m_ui.pageTree), 0); + m_ui.splitter->setStretchFactor(m_ui.splitter->indexOf(m_ui.layoutWidget), 1); +} + +SettingsDialog::~SettingsDialog() +{ +} + +void SettingsDialog::pageSelected() +{ + QTreeWidgetItem *item = m_ui.pageTree->currentItem(); + PageData data = item->data(0, Qt::UserRole).value(); + int index = data.index; + m_currentCategory = data.category; + m_currentPage = data.id; + m_ui.stackedPages->setCurrentIndex(index); +} + +void SettingsDialog::accept() +{ + m_applied = true; + Q_FOREACH(IOptionsPage *page, m_pages) + { + page->apply(); + page->finish(); + } + done(QDialog::Accepted); +} + +void SettingsDialog::reject() +{ + Q_FOREACH(IOptionsPage *page, m_pages) + page->finish(); + done(QDialog::Rejected); +} + +void SettingsDialog::apply() +{ + Q_FOREACH(IOptionsPage *page, m_pages) + page->apply(); + m_applied = true; +} + +bool SettingsDialog::execDialog() +{ + m_applied = false; + exec(); + return m_applied; +} + +void SettingsDialog::done(int val) +{ + QDialog::done(val); +} + +} /* namespace Core */ \ No newline at end of file diff --git a/code/studio/src/plugins/core/settings_dialog.h b/code/studio/src/plugins/core/settings_dialog.h new file mode 100644 index 000000000..9e1c86444 --- /dev/null +++ b/code/studio/src/plugins/core/settings_dialog.h @@ -0,0 +1,75 @@ +// Object Viewer Qt - MMORPG Framework +// Copyright (C) 2010 Winch Gate Property Limited +// Copyright (C) 2011 Dzmitry Kamiahin +// Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +#ifndef SETTINGS_DIALOG_H +#define SETTINGS_DIALOG_H + +#include "ui_settings_dialog.h" + +// Qt includes +#include + +// Project includes +#include "../../extension_system/iplugin_manager.h" + +namespace Core +{ +class IOptionsPage; + +/** +@class CSettingsDialog +@brief Settings dialog +*/ +class SettingsDialog: public QDialog +{ + Q_OBJECT + +public: + SettingsDialog(ExtensionSystem::IPluginManager *pluginManager, + const QString &initialCategory = QString(), + const QString &initialPage = QString(), + QWidget *parent = 0); + + ~SettingsDialog(); + + /// Run the dialog and return true if 'Ok' was choosen or 'Apply' was invoked at least once + bool execDialog(); + +public Q_SLOTS: + void done(int); + +private Q_SLOTS: + void pageSelected(); + void accept(); + void reject(); + void apply(); + +private: + QList m_pages; + bool m_applied; + QString m_currentCategory; + QString m_currentPage; + + ExtensionSystem::IPluginManager *m_plugMan; + + Ui::SettingsDialog m_ui; +}; /* class CSettingsDialog */ + +} /* namespace Core */ + +#endif // SETTINGS_DIALOG_H diff --git a/code/studio/src/plugins/core/settings_dialog.ui b/code/studio/src/plugins/core/settings_dialog.ui new file mode 100644 index 000000000..8e9780c9a --- /dev/null +++ b/code/studio/src/plugins/core/settings_dialog.ui @@ -0,0 +1,126 @@ + + + SettingsDialog + + + + 0 + 0 + 697 + 476 + + + + Settings + + + + :/core/images/preferences.png:/core/images/preferences.png + + + + 6 + + + 9 + + + + + Qt::Horizontal + + + + + 0 + 0 + + + + 1 + + + + 0 + + + + + + + 6 + + + 0 + + + + + + 350 + 250 + + + + + + + + Qt::Horizontal + + + + + + + + + + + Qt::Horizontal + + + QDialogButtonBox::Apply|QDialogButtonBox::Cancel|QDialogButtonBox::Ok + + + + + + + + + + + buttonBox + accepted() + SettingsDialog + accept() + + + 297 + 361 + + + 297 + 193 + + + + + buttonBox + rejected() + SettingsDialog + reject() + + + 297 + 361 + + + 297 + 193 + + + + +