File indexing completed on 2024-04-14 05:44:15

 /*
     SPDX-FileCopyrightText: 2006-2008 Robert Knight <robertknight@gmail.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #ifndef VIEWMANAGER_H
 #define VIEWMANAGER_H
 
 // Qt
 #include <QAction>
 #include <QHash>
 #include <QObject>
 #include <QPointer>
 
 #include "konsoleprivate_export.h"
 // Konsole
 
 class KActionCollection;
 class KConfigGroup;
 
 namespace Konsole
 {
 class ColorScheme;
 class Profile;
 class Session;
 class SessionController;
 class TabbedViewContainer;
 class TabbedViewContainer;
 class TerminalDisplay;
 class ViewProperties;
 class ViewSplitter;
 
 /**
  * Manages the terminal display widgets in a Konsole window or part.
  *
  * When a view manager is created, it constructs a tab widget ( accessed via
  * widget() ) to hold one or more view splitters.  Each view splitter holds
  * one or more terminal displays  and splitters.
  *
  * The view manager provides menu actions ( defined in the 'konsoleui.rc' XML file )
  * to manipulate the views and view containers - for example, actions to split the view
  * left/right or top/bottom, detach a view from the current window and navigate between
  * views and containers.  These actions are added to the collection specified in the
  * ViewManager's constructor.
  *
  * The view manager provides facilities to construct display widgets for a terminal
  * session and also to construct the SessionController which provides the menus and other
  * user interface elements specific to each display/session pair.
  *
  */
 class KONSOLEPRIVATE_EXPORT ViewManager : public QObject
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.konsole.Window")
 
 public:
     /**
      * Constructs a new view manager with the specified @p parent.
      * View-related actions defined in 'konsoleui.rc' are created
      * and added to the specified @p collection.
      */
     ViewManager(QObject *parent, KActionCollection *collection);
     ~ViewManager() override;
 
     /**
      * Creates a new view to display the output from and deliver input to @p session.
      * Constructs a new container to hold the views if no container has yet been created.
      */
     void createView(TabbedViewContainer *tabWidget, Session *session);
 
     /*
      * Applies the view-specific settings associated with specified @p profile
      * to the terminal display @p view.
      */
     void applyProfileToView(TerminalDisplay *view, const QExplicitlySharedDataPointer<Profile> &profile);
 
     void toggleActionsBasedOnState();
     /**
      * Return the main widget for the view manager which
      * holds all of the views managed by this ViewManager instance.
      */
     QWidget *widget() const;
 
     /**
      * Returns the view manager's active view.
      */
     QWidget *activeView() const;
 
     /**
      * Returns the list of view properties for views in the active container.
      * Each view widget is associated with a ViewProperties instance which
      * provides access to basic information about the session being
      * displayed in the view, such as title, current directory and
      * associated icon.
      */
     QList<ViewProperties *> viewProperties() const;
 
     /**
      * This enum describes the available types of navigation widget
      * which newly created containers can provide to allow navigation
      * between open sessions.
      */
     enum NavigationMethod {
         /**
          * Each container has a row of tabs (one per session) which the user
          * can click on to navigate between open sessions.
          */
         TabbedNavigation,
         /** The container has no navigation widget. */
         NoNavigation,
     };
 
     /**
      * Describes the options for showing or hiding the container's navigation widget.
      */
     enum NavigationVisibility {
         NavigationNotSet, // Don't rely on this information, Only use the settings.
         AlwaysShowNavigation,
         ShowNavigationAsNeeded,
         AlwaysHideNavigation,
     };
 
     /**
      * Sets the visibility of the view container's navigation widget.
      * The ViewContainer subclass is responsible for ensuring that this
      * setting is respected as views are dded or removed from the container
      */
     void setNavigationVisibility(NavigationVisibility navigationVisibility);
 
     /** Returns the current mode for controlling the visibility of the
      * view container's navigation widget.
      */
     NavigationVisibility navigationVisibility() const;
 
     /**
      * Sets the type of widget provided to navigate between open sessions
      * in a container.  The changes will only apply to newly created containers.
      *
      * The default method is TabbedNavigation.  To disable navigation widgets, call
      * setNavigationMethod(ViewManager::NoNavigation) before creating any sessions.
      */
     void setNavigationMethod(NavigationMethod method);
 
     /**
      * Returns the type of navigation widget created in new containers.
      * See setNavigationMethod()
      */
     NavigationMethod navigationMethod() const;
 
     /**
      * Returns the controller for the active view.  activeViewChanged() is
      * emitted when this changes.
      */
     SessionController *activeViewController() const;
 
     /**
      * Session management
      */
     void saveSessions(KConfigGroup &group);
     void restoreSessions(const KConfigGroup &group);
 
     int managerId() const;
 
     /** Returns a list of sessions in this ViewManager */
     QList<Session *> sessions()
     {
         return _sessionMap.values();
     }
 
     /**
      * Returns whether the @p profile has the blur setting enabled
      */
     static bool profileHasBlurEnabled(const QExplicitlySharedDataPointer<Profile> &profile);
 
     /** returns the active tab from the view
      */
     TabbedViewContainer *activeContainer();
     TerminalDisplay *createView(Session *session);
     void attachView(TerminalDisplay *terminal, Session *session);
 
     static std::shared_ptr<const ColorScheme> colorSchemeForProfile(const QExplicitlySharedDataPointer<Profile> &profile);
     /** Reorder the terminal display history list */
     void updateTerminalDisplayHistory(TerminalDisplay *terminalDisplay = nullptr, bool remove = false);
 
     QHash<TerminalDisplay *, Session *> forgetAll(ViewSplitter *splitter);
     Session *forgetTerminal(TerminalDisplay *terminal);
 
     /**
      * Creates and returns new session
      *
      * The session has specified @p profile, working @p directory
      * and configured environment.
      */
     Session *createSession(const QExplicitlySharedDataPointer<Profile> &profile, const QString &directory = QString());
 
 Q_SIGNALS:
     /** Emitted when the last view is removed from the view manager */
     void empty();
 
     /** Emitted when a session is detached from a view owned by this ViewManager */
     void terminalsDetached(ViewSplitter *splitter, QHash<TerminalDisplay *, Session *> sessionsMap);
 
     /**
      * Emitted when the active view changes.
      * @param controller The controller associated with the active view
      */
     void activeViewChanged(SessionController *controller);
 
     /**
      * Emitted when the current session needs unplugged from factory().
      * @param controller The controller associated with the active view
      */
     void unplugController(SessionController *controller);
 
     /**
      * Emitted when the list of view properties ( as returned by viewProperties() ) changes.
      * This occurs when views are added to or removed from the active container, or
      * if the active container is changed.
      */
     void viewPropertiesChanged(const QList<ViewProperties *> &propertiesList);
 
     /**
      * Emitted when menu bar visibility changes because a profile that requires so is
      * activated.
      */
     void setMenuBarVisibleRequest(bool);
     void updateWindowIcon();
 
     void blurSettingChanged(bool);
 
     /** Requests creation of a new view with the default profile. */
     void newViewRequest();
     /** Requests creation of a new view, with the selected profile. */
     void newViewWithProfileRequest(const QExplicitlySharedDataPointer<Profile> &profile);
 
     void activationRequest(const QString &xdgActivationToken);
 
 public Q_SLOTS:
     /** DBus slot that returns the number of sessions in the current view. */
     Q_SCRIPTABLE int sessionCount();
 
     /**
      * DBus slot that returns the unique ids of the sessions in the
      * current view.  The returned list is ordered by tab.
      * QList<int> is not printable by qdbus so we use QStringList
      * Example:
      *  A) create tab, create tab 2, create tab 3, go to tab 2, split view
      *     sessionList() returns 1 4 2 3
      *  B) create tab, create tab 2, split view, create tab 3
      *     sessionList() returns 1 3 2 4
      */
     Q_SCRIPTABLE QStringList sessionList();
 
     /** DBus slot that returns the current (active) session window */
     Q_SCRIPTABLE int currentSession();
 
     /** DBus slot that sets the current (active) session window */
     Q_SCRIPTABLE void setCurrentSession(int sessionId);
 
     /** DBus slot that creates a new session in the current view with the associated
      * default profile and the default working directory
      */
     Q_SCRIPTABLE int newSession();
 
     /** DBus slot that creates a new session in the current view.
      * @param profile the name of the profile to be used
      * started.
      */
     Q_SCRIPTABLE int newSession(const QString &profile);
 
     /** DBus slot that creates a new session in the current view.
      * @param profile the name of the profile to be used
      * @param directory the working directory where the session is
      * started.
      */
     Q_SCRIPTABLE int newSession(const QString &profile, const QString &directory);
 
     // TODO: its semantic is application-wide. Move it to more appropriate place
     // DBus slot that returns the name of default profile
     Q_SCRIPTABLE QString defaultProfile();
 
     // TODO: its semantic is application-wide. Move it to more appropriate place
     // DBus slot that sets the default profile
     Q_SCRIPTABLE void setDefaultProfile(const QString &profile);
 
     // TODO: its semantic is application-wide. Move it to more appropriate place
     // DBus slot that returns a string list of defined (known) profiles
     Q_SCRIPTABLE QStringList profileList();
 
     /** DBus slot that changes the view port to the next session */
     Q_SCRIPTABLE void nextSession();
 
     /** DBus slot that changes the view port to the previous session */
     Q_SCRIPTABLE void prevSession();
 
     /** DBus slot that switches the current session (as returned by
      * currentSession()) with the left (or previous) one in the
      * navigation tab.
      */
     Q_SCRIPTABLE void moveSessionLeft();
 
     /** DBus slot that Switches the current session (as returned by
      * currentSession()) with the right (or next) one in the navigation
      * tab.
      */
     Q_SCRIPTABLE void moveSessionRight();
 
     /** DBus slot that sets ALL tabs' width to match their text */
     Q_SCRIPTABLE void setTabWidthToText(bool);
 
     // Creates json file with split config
     Q_SCRIPTABLE void saveLayoutFile();
     Q_SCRIPTABLE void loadLayoutFile();
     Q_SCRIPTABLE void loadLayout(QString File);
 
     /** DBus slot that returns a description of the layout hierarchy
      * in each tab.
      *
      * A ViewSplitter is described by its id enclosed in round brackets,
      * followed by square (horizontal split) or curly (vertical split)
      * brackets. Format: (%id)[...] OR (%id){...}
      *
      * A TerminalDisplay is simply described by its id.
      *
      * The child widgets of a ViewSplitter are described in the square or
      * curly brackets using their ids and are separated by '|'. The
      * order which they are described in is top to bottom for vertical
      * split or left to right for horizontal split.
      */
     Q_SCRIPTABLE QStringList viewHierarchy();
 
     /** DBus slot that returns the sizes of the direct child widgets as
      * percentages of the size of the ViewSplitter in the form of a
      * list. Will return an empty list if a splitter with id splitterId
      * cannot be found.
      */
     Q_SCRIPTABLE QList<double> getSplitProportions(int splitterId);
 
     /** DBus slot that splits an existing view in the current tab **/
     Q_SCRIPTABLE bool createSplit(int viewId, bool horizontalSplit);
 
     /** DBus slot that creates a splitter containing a series of
      * existing widgets and inserts it at an index in an existing splitter.
      *
      * Each element in widgetInfos is QString of format "x-y", describing
      * each moved widget. Regarding the to-be-created splitter, the first
      * QString will represent the leftmost widget (horizontal split)
      * or the topmost widget (vertical split). x is either 's'
      * for a ViewSplitter or 'v' for a TerminalDisplay. y is the id of
      * the widget.
      */
     Q_SCRIPTABLE bool createSplitWithExisting(int targetSplitterId, QStringList widgetInfos, int idx, bool horizontalSplit);
 
     /** DBus slot that focuses a view. **/
     Q_SCRIPTABLE bool setCurrentView(int viewId);
 
     /** DBus slot that allows setting of the relative sizes of widgets
      * in a splitter by specifying their percentages.
      */
     /* NOTE: not all ways of calling dbus can handle "ad" QList<double>
         Does not work AFAIK: qdbus6, qdbusviewer6, busctl
         Works: dbus-send, gdbus
          Example:
             dbus-send --session --print-reply=literal --type=method_call --dest=org.kde.konsole-16710 /Windows/1   org.kde.konsole.Window.resizeSplits int32:0 array:double:40.0,60.0
             gdbus call --session --dest org.kde.konsole-16710  --object-path /Windows/1 --method org.kde.konsole.Window.resizeSplits 0 "[10.5, 89.5]"
     */
     Q_SCRIPTABLE bool resizeSplits(int splitterId, QList<double> percentages);
 
     /** DBus slot that moves a splitter to a different position under a specified splitter**/
     Q_SCRIPTABLE bool moveSplitter(int splitterId, int targetSplitterId, int idx);
 
     /** DBus slot that move a view to a different position under a specified splitter**/
     Q_SCRIPTABLE bool moveView(int viewId, int targetSplitterId, int idx);
 
 private Q_SLOTS:
     // called when the "Split View Left/Right" menu item is selected
     void splitLeftRight();
     void splitTopBottom();
     void splitAuto(bool fromNextTab = false);
     void splitLeftRightNextTab();
     void splitTopBottomNextTab();
     void splitAutoNextTab();
     void expandActiveContainer();
     void shrinkActiveContainer();
     void equalSizeAllContainers();
 
     // called when the "Detach View" menu item is selected
     void detachActiveView();
     void detachActiveTab();
 
     // called when a session terminates - the view manager will delete any
     // views associated with the session
     void sessionFinished(Session *session);
     // called when one view has been destroyed
     void viewDestroyed(QWidget *view);
 
     // controller detects when an associated view is given the focus
     // and emits a signal.  ViewManager listens for that signal
     // and then plugs the action into the UI
     // void viewFocused( SessionController* controller );
 
     // called when the active view in a ViewContainer changes, so
     // that we can plug the appropriate actions into the UI
     void activateView(TerminalDisplay *view);
 
     void focusUp();
     void focusDown();
     void focusLeft();
     void focusRight();
 
     // called when "Next View" shortcut is activated
     void nextView();
 
     // called when "Previous View" shortcut is activated
     void previousView();
 
     // called when "Switch to last tab" shortcut is activated
     void lastView();
 
     // called when "Switch to last used tab" shortcut is activated
     void lastUsedView();
 
     // called when "Switch to last used tab (reverse)" shortcut is activated
     void lastUsedViewReverse();
 
     // called when "Next View Container" shortcut is activated
     void nextContainer();
 
     // called when "Toggle Two tabs" shortcut is activated
     void toggleTwoViews();
 
     // called when the views in a container owned by this view manager
     // changes
     void containerViewsChanged(TabbedViewContainer *container);
 
     // called when a profile changes
     void profileChanged(const QExplicitlySharedDataPointer<Profile> &profile);
 
     void updateViewsForSession(Session *session);
 
     // moves active view to the left
     void moveActiveViewLeft();
     // moves active view to the right
     void moveActiveViewRight();
     // switches to the view at visual position 'index'
     // in the current container
     void switchToView(int index);
     // gives focus and switches the terminal display, changing tab if needed
     void switchToTerminalDisplay(TerminalDisplay *terminalDisplay);
 
     // called when a SessionController gains focus
     void controllerChanged(SessionController *controller);
 
     /**
      * Disconnect this ViewManager and MainWindow from @p controller
      * and its associated view/session pair such as after a split-view
      * has been drag-and-dropped to a new window.
      */
     void forgetController(SessionController *controller);
 
     /* Detaches the tab at index tabIdx */
     void detachTab(int tabIdx);
 
     void semanticSetupBash();
 
     void toggleSemanticHints();
 
     void toggleLineNumbers();
 
 private:
     Q_DISABLE_COPY(ViewManager)
 
     TerminalDisplay *findTerminalDisplay(int viewId);
 
     void setCurrentView(TerminalDisplay *view);
 
     void createView(Session *session, TabbedViewContainer *container, int index);
 
     void setupActions();
 
     // takes a view from a view container owned by a different manager and places it in
     // newContainer owned by this manager
     void takeView(ViewManager *otherManager, TabbedViewContainer *otherContainer, TabbedViewContainer *newContainer, TerminalDisplay *view);
     void splitView(Qt::Orientation orientation, bool fromNextTab = false);
 
     // creates a new container which can hold terminal displays
     TabbedViewContainer *createContainer();
 
     // creates a new terminal display
     // the 'session' is used so that the terminal display's random seed
     // can be set to something which depends uniquely on that session
     TerminalDisplay *createTerminalDisplay(Session *session = nullptr);
 
     // creates a new controller for a session/display pair which provides the menu
     // actions associated with that view, and exposes basic information
     // about the session ( such as title and associated icon ) to the display.
     SessionController *createController(Session *session, TerminalDisplay *view);
     void removeController(SessionController *controller);
 
     // Activates a different terminal when the TerminalDisplay
     // closes or is detached and another one should be focused.
     // It will activate the last used terminal within the same splitView
     // if possible otherwise it will focus the last used tab
     void focusAnotherTerminal(ViewSplitter *toplevelSplitter);
 
     void activateLastUsedView(bool reverse);
 
     void registerTerminal(TerminalDisplay *terminal);
     void unregisterTerminal(TerminalDisplay *terminal);
 
 private:
     QPointer<TabbedViewContainer> _viewContainer;
     QPointer<SessionController> _pluggedController;
 
     QHash<TerminalDisplay *, Session *> _sessionMap;
 
     KActionCollection *_actionCollection;
 
     NavigationMethod _navigationMethod;
     NavigationVisibility _navigationVisibility;
     int _managerId;
     static int lastManagerId;
     QList<TerminalDisplay *> _terminalDisplayHistory;
     int _terminalDisplayHistoryIndex;
 
     // List of actions that should only be enabled when there are multiple view
     // containers open
     QList<QAction *> _multiTabOnlyActions;
     QList<QAction *> _multiSplitterOnlyActions;
 };
 }
 
 #endif