C4ConsoleQtState.h

Go to the documentation of this file.

/*
 * OpenClonk, http://www.openclonk.org
 *
 * Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
 * Copyright (c) 2013, The OpenClonk Team and contributors
 *
 * Distributed under the terms of the ISC license; see accompanying file
 * "COPYING" for details.
 *
 * "Clonk" is a registered trademark of Matthes Bender, used with permission.
 * See accompanying file "TRADEMARK" for details.
 *
 * To redistribute this file separately, substitute the full license texts
 * for the above references.
 */
 
/* Editor windows using Qt - internal state */
 
#ifndef INC_C4ConsoleQtState
#define INC_C4ConsoleQtState
 
#ifdef WITH_QT_EDITOR
 
#include "C4Include.h" // needed for automoc
#include "editor/C4ConsoleGUI.h"
#include "editor/C4ToolsDlg.h"
#include "editor/C4ConsoleQt.h"
#include "ui_C4ConsoleQtMainWindow.h"
 
/* Forward string translation to GetResStr */
 
class C4ConsoleQtTranslator : public QTranslator
{
    Q_OBJECT
public:
    bool isEmpty() const override { return false; }
    QString translate(const char * context, const char * sourceText, const char * disambiguation = nullptr, int n = -1) const override;
};
 
extern C4ConsoleQtTranslator qt_translator;
 
class C4ConsoleClientAction : public QAction
{
    Q_OBJECT
 
    int32_t client_id;
    C4ConsoleGUI::ClientOperation op;
        
public:
    C4ConsoleClientAction(int32_t client_id, const char *text, QObject *parent, C4ConsoleGUI::ClientOperation op);
    int32_t GetClientID() const { return client_id; }
    private slots:
    void Execute();
};
 
class C4ConsoleRemovePlayerAction : public QAction
{
    Q_OBJECT
 
        int32_t player_num;
public:
    C4ConsoleRemovePlayerAction(int32_t player_num, const char *text, QObject *parent);
    int32_t GetPlayerNum() const { return player_num; }
    private slots:
    void Execute();
};
 
class C4ConsoleOpenViewportAction : public QAction
{
    Q_OBJECT
 
        int32_t player_num;
public:
    C4ConsoleOpenViewportAction(int32_t player_num, const char *text, QObject *parent);
    int32_t GetPlayerNum() const { return player_num; }
    private slots:
    void Execute();
};
 
/* Disable shortcut on some actions */
 
class C4DisableShortcutFilter : public QObject
{
    Q_OBJECT
 
public:
    C4DisableShortcutFilter(QObject *parent) : QObject(parent) {}
 
    bool eventFilter(QObject *target, QEvent *event) override
    {
        if (event->type() == QEvent::Shortcut) return true;
        return QObject::eventFilter(target, event);
    }
};
 
class C4ConsoleQtMainWindow : public QMainWindow
{
    Q_OBJECT
    class C4ConsoleGUIState *state;
 
protected:
    void keyPressEvent(QKeyEvent * event) override;
    void keyReleaseEvent(QKeyEvent * event) override;
 
public:
    C4ConsoleQtMainWindow(class C4AbstractApp *app, class C4ConsoleGUIState *state);
 
    void closeEvent(class QCloseEvent *event) override;
    void LoadGeometry();
    class C4ConsoleGUIState *GetConsoleState() const { return state; }
 
public slots:
    // Toolbar items
    void PlayPressed(bool down);
    void PausePressed(bool down);
    void CursorGamePressed(bool down);
    void CursorSelectPressed(bool down);
    void CursorCreateObjPressed(bool down);
    void CursorDrawPenPressed(bool down);
    void CursorDrawLinePressed(bool down);
    void CursorDrawRectPressed(bool down);
    void CursorFillPressed(bool down);
    void CursorPickerPressed(bool down);
    void DynamicLandscapePressed(bool down);
    void StaticLandscapePressed(bool down);
    void StaticFlatLandscapePressed(bool down);
    void ExactLandscapePressed(bool down);
    void DrawSizeChanged(int newval);
    void OpenTranslationsOverview();
    // File menu
    void FileNew();
    void FileOpen();
    void FileOpenInNetwork();
    void FileOpenWithPlayers();
    void FileRecord();
    void FileSave();
    void FileSaveAs();
    void FileSaveGameAs();
    void FileExportPacked();
    void FileClose();
    void FileQuit();
    void FileReInitScenario();
    // Player menu
    void PlayerJoin();
    // Window menu
    void ViewportNew();
    // Help menu
    void HelpAbout();
    void HelpToggle(bool enabled);
    // Console edits enter pressed events
    void MainConsoleEditEnter(); // console edit below log
    void PropertyConsoleEditEnter(); // console edit of property window
    // View selection changes
    void OnCreatorSelectionChanged(const QItemSelection & selected, const QItemSelection & deselected);
    void OnCreatorCurrentChanged(const QModelIndex & current, const QModelIndex & previous);
    void OnObjectListSelectionChanged(const QItemSelection & selected, const QItemSelection & deselected);
    void AscendPropertyPath();
    void AddArrayElement();
    void RemoveArrayElement();
    // Global editor key processing
    bool HandleEditorKeyDown(QKeyEvent *event);
    bool HandleEditorKeyUp(QKeyEvent *event);
    // Material changed in landscape drawing mode
    void ForegroundMaterialChanged(const QString &new_selection);
    void BackgroundMaterialChanged(const QString &new_selection);
    // Links on welcome page
    void WelcomeLinkActivated(const QString &link);
    // Object context menu
    void SelectionDelete();
    void SelectionDuplicate();
    void SelectionEjectContents();
    // Shortcut actions
    void FocusGlobalScriptBox();
    void FocusObjectScriptBox();
    void OpenMaterialSelection();
    void FocusNextViewport();
    void GradeUp();
    void GradeDown();
};
 
 
/* Main Qt editor class controlled through ControlGUI */
 
class C4ConsoleGUIState // Avoid direct declaration of C4ConsoleGUI::State because qmake doesn't like some declarations in the nested class
{
public:
    std::unique_ptr<QApplication> application;
    std::unique_ptr<C4ConsoleQtMainWindow> window;
    std::unique_ptr<class C4ConsoleQtPropListModel> property_model;
    std::unique_ptr<class C4PropertyDelegateFactory> property_delegate_factory;
    std::unique_ptr<class C4PropertyNameDelegate> property_name_delegate;
    std::unique_ptr<class C4ConsoleQtObjectListModel> object_list_model;
    std::unique_ptr<class C4ConsoleQtDefinitionListModel> definition_list_model;
    std::unique_ptr<class C4DisableShortcutFilter> disable_shortcut_filter;
    std::unique_ptr<class C4ConsoleQtLocalizeOverviewDlg> translation_overview_dialogue;
    std::list<class C4ConsoleQtViewportDockWidget *> viewports;
    std::list<std::unique_ptr<C4ConsoleClientAction> > client_actions;
    std::list<std::unique_ptr<C4ConsoleRemovePlayerAction> > player_actions;
    std::list<std::unique_ptr<C4ConsoleOpenViewportAction> > viewport_actions;
    Ui::MainWindow ui;
 
    // ptrs owned by window
    QMainWindow *viewport_area;
    QLabel *status_cursor, *status_framecounter, *status_timefps;
    QAction *window_menu_separator;
 
    // Current editor/tool states
    // Cannot use direct members in C4EditorCursor because callbacks into the GUI happen before the values change.
    // If other C4Console implementations are removed, the state could be merged and these members removed.
    bool enabled, recording, net_enabled;
    LandscapeMode landscape_mode;
    bool flat_chunk_shapes;
    int32_t editcursor_mode, drawing_tool;
    StdCopyStrBuf material, texture, back_material, back_texture;
 
    // Updating states to prevent callbacks on internal selection updates
    int32_t is_object_selection_updating;
 
    // Currently selected single object
    C4Value action_object;
 
    C4ConsoleGUIState(C4ConsoleGUI *console);
    ~C4ConsoleGUIState();
 
    void AddToolbarSpacer(int space);
    bool CreateConsoleWindow(C4AbstractApp *app);
    void DeleteConsoleWindow();
    void Execute(bool redraw_only=false);
    void Redraw() { Execute(true); }
    void UpdateActionStates();
    void UpdateMatTex();
    void UpdateBackMatTex();
    // Set modes and tools
    void SetEnabled(bool to_enabled) { enabled = to_enabled; UpdateActionStates(); ReInitDefinitions(); }
    void SetLandscapeMode(LandscapeMode to_landscape_mode, bool to_flat_chunk_shapes) { landscape_mode = to_landscape_mode; flat_chunk_shapes = to_flat_chunk_shapes; UpdateActionStates(); }
    void SetEditCursorMode(int32_t to_editcursor_mode) { editcursor_mode = to_editcursor_mode; UpdateActionStates(); }
    void SetDrawingTool(int32_t to_drawing_tool) { drawing_tool = to_drawing_tool; UpdateActionStates(); }
    void SetMaterial(const char *new_material) { material.Copy(new_material); UpdateMatTex(); }
    void SetTexture(const char *new_texture) { texture.Copy(new_texture); UpdateMatTex(); }
    void SetBackMaterial(const char *new_material) { back_material.Copy(new_material); UpdateBackMatTex(); }
    void SetBackTexture(const char *new_texture) { back_texture.Copy(new_texture); UpdateBackMatTex(); }
    void SetRecording(bool to_recording) { recording = to_recording; UpdateActionStates(); }
    void SetNetEnabled(bool enabled) { net_enabled = enabled; UpdateActionStates(); }
    
    void AddNetMenuItem(int32_t index, const char *text, C4ConsoleGUI::ClientOperation op);
    void ClearNetMenu();
    void AddKickPlayerMenuItem(int32_t plr, const char *text, bool item_enabled);
    void ClearPlayerMenu();
    void AddPlayerViewportMenuItem(int32_t plr, const char *text);
    void ClearViewportMenu();
    void AddViewport(class C4ViewportWindow *cvp);
    void RemoveViewport(class C4ViewportWindow *cvp);
    void SetInputFunctions(std::list<const char*> &functions);
    void PropertyDlgUpdate(C4EditCursorSelection &rSelection, bool force_function_update);
    void ReInitDefinitions();
    void OnCreatorSelectionChanged(const QItemSelection & selected, const QItemSelection & deselected);
    void SetObjectSelection(class C4EditCursorSelection &rSelection);
    void OnObjectListSelectionChanged(const QItemSelection & selected, const QItemSelection & deselected);
    void OnCreatorCurrentChanged(const QModelIndex & current, const QModelIndex & previous);
    void UpdateActionObject(C4Object *new_action_object);
 
    bool CreateNewScenario(StdStrBuf *out_filename, bool *out_host_as_network); // show "new scenario" dialogue; return true if new scenario is created
 
#ifdef USE_WIN32_WINDOWS
    bool HandleWin32KeyboardMessage(MSG *msg);
#endif
 
    void InitWelcomeScreen();
    void ShowWelcomeScreen();
    void HideWelcomeScreen();
 
    void ClearGamePointers();
 
    void Draw(C4TargetFacet &cgo);
};
 
class C4ConsoleGUI::State : public C4ConsoleGUIState
{
public:
    State(C4ConsoleGUI *console) : C4ConsoleGUIState(console) {}
};
 
class C4ToolsDlg::State : C4ConsoleGUI::InternalState<class C4ToolsDlg>
{
public:
    State(C4ToolsDlg *toolsDlg) : C4ConsoleGUI::InternalState<class C4ToolsDlg>(toolsDlg) {}
    ~State() = default;
 
    void Clear() {}
    void Default() {}
};
 
#endif // WITH_QT_EDITOR
#endif // INC_C4ConsoleQtState