EIC code displayed by LXR master/​include/​root/​ROOT/​RCanvas.hxx	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-11-05 09:55:18

 /*************************************************************************
  * Copyright (C) 1995-2015, Rene Brun and Fons Rademakers.               *
  * All rights reserved.                                                  *
  *                                                                       *
  * For the licensing terms see $ROOTSYS/LICENSE.                         *
  * For the list of contributors see $ROOTSYS/README/CREDITS.             *
  *************************************************************************/
 
 #ifndef ROOT7_RCanvas
 #define ROOT7_RCanvas
 
 #include "ROOT/RPadBase.hxx"
 #include "ROOT/RVirtualCanvasPainter.hxx"
 #include "ROOT/RDrawableRequest.hxx"
 
 #include <memory>
 #include <string>
 #include <vector>
 #include <list>
 
 namespace ROOT {
 namespace Experimental {
 
 class RChangeAttrRequest : public RDrawableRequest {
    std::vector<std::string> ids;                           ///< array of ids
    std::vector<std::string> names;                         ///< array of attribute names
    std::vector<std::unique_ptr<RAttrMap::Value_t>> values; ///< array of values
    bool update{true};                                      ///< update canvas at the end
    bool fNeedUpdate{false};       ///<! is canvas update required
    RChangeAttrRequest(const RChangeAttrRequest &) = delete;
    RChangeAttrRequest& operator=(const RChangeAttrRequest &) = delete;
 public:
    RChangeAttrRequest() = default; // for I/O
    ~RChangeAttrRequest() override = default;
    std::unique_ptr<RDrawableReply> Process() override;
    bool NeedCanvasUpdate() const override { return fNeedUpdate; }
 };
 
 /** \class RCanvas
 \ingroup GpadROOT7
 \brief A window's topmost `RPad`.
 \author Axel Naumann <axel@cern.ch>
 \date 2015-07-08
 \warning This is part of the ROOT 7 prototype! It will change without notice. It might trigger earthquakes. Feedback is welcome!
 */
 
 class RCanvas: public RPadBase {
 friend class RPadBase;  /// use for ID generation
 friend class RCanvasPainter; /// used for primitives drawing
 friend class RChangeAttrRequest; /// to apply attributes changes
 private:
    /// Title of the canvas.
    std::string fTitle;
 
    /// Width of the canvas in pixels
    int fWidth{0};
 
    /// Height of the canvas in pixels
    int fHeight{0};
 
    /// Modify counter, incremented every time canvas is changed
    Version_t fModified{1}; ///<!
 
    /// The painter of this canvas, bootstrapping the graphics connection.
    /// Unmapped canvases (those that never had `Draw()` invoked) might not have
    /// a painter.
    std::unique_ptr<Internal::RVirtualCanvasPainter> fPainter; ///<!
 
    /// indicate if Show() method was called before
    bool fShown{false}; ///<!
 
    /// indicate if Update() method was called before
    bool fUpdated{false}; ///<!
 
    /// Disable copy construction for now.
    RCanvas(const RCanvas &) = delete;
 
    /// Disable assignment for now.
    RCanvas &operator=(const RCanvas &) = delete;
 
    // Increment modify counter
    uint64_t IncModified() { return ++fModified; }
 
 public:
    static std::shared_ptr<RCanvas> Create(const std::string &title);
 
    /// Create a temporary RCanvas; for long-lived ones please use Create().
    RCanvas() : RPadBase("canvas") {}
 
    ~RCanvas() override = default;
 
    const RCanvas *GetCanvas() const override { return this; }
 
    /// Access to the top-most canvas, if any (non-const version).
    RCanvas *GetCanvas() override { return this; }
 
    /// Set canvas pixel size - width and height
    void SetSize(int width, int height)
    {
       fWidth = width;
       fHeight = height;
    }
 
    /// Set canvas width
    void SetWidth(int width) { fWidth = width; }
 
    /// Set canvas height
    void SetHeight(int height) { fHeight = height; }
 
    /// Get canvas width
    int GetWidth() const { return fWidth; }
 
    /// Get canvas height
    int GetHeight() const { return fHeight; }
 
    /// Display the canvas.
    void Show(const std::string &where = "");
 
    /// returns true if Show() method was called
    bool IsShown() const { return fShown; }
 
    /// clear IsShown() flag
    void ClearShown() { fShown = false; }
 
    /// Returns window name used to display canvas
    std::string GetWindowAddr() const;
 
    /// Returns window URL which can be used for connection
    std::string GetWindowUrl(bool remote);
 
    Internal::RVirtualCanvasPainter *GetPainter();
 
    std::shared_ptr<RWebWindow> GetWindow();
 
    /// Hide all canvas displays
    void Hide();
 
    /// Remove canvas from global canvas lists, will be destroyed when shared_ptr will be removed
    void Remove();
 
    /// Insert panel into the canvas, canvas should be shown at this moment
    template <class PANEL>
    bool AddPanel(std::shared_ptr<PANEL> &panel)
    {
       if (!fPainter) return false;
       return fPainter->AddPanel(panel->GetWindow());
    }
 
    /// Get modify counter
    uint64_t GetModified() const { return fModified; }
 
    // Set newest version to all primitives
    void Modified() { SetDrawableVersion(IncModified()); }
 
    /// Set newest version to specified drawable
    void Modified(std::shared_ptr<RDrawable> drawable)
    {
       // TODO: may be check that drawable belong to the canvas
       if (drawable)
          drawable->SetDrawableVersion(IncModified());
    }
 
    // Return if canvas was modified and not yet updated
    bool IsModified() const;
 
    /// update drawing
    void Update(bool async = false, CanvasCallback_t callback = nullptr);
 
    /// returns true if Update() method was called
    bool IsUpdated() const { return fUpdated; }
 
    /// clear IsUpdated() flag
    void ClearUpdated() { fUpdated = false; }
 
    /// Run canvas functionality for given time (in seconds)
    void Run(double tm = 0.);
 
    /// Save canvas in image file
    bool SaveAs(const std::string &filename);
 
    /// Provide JSON which can be used for offline display
    std::string CreateJSON();
 
    std::string GetUID() const;
 
    /// Get the canvas's title.
    const std::string &GetTitle() const { return fTitle; }
 
    /// Set the canvas's title.
    RCanvas &SetTitle(const std::string &title)
    {
       fTitle = title;
       return *this;
    }
 
    void ResolveSharedPtrs();
 
    void ClearOnClose(const std::shared_ptr<void> &handle);
 
    static const std::vector<std::shared_ptr<RCanvas>> GetCanvases();
 
    static void ReleaseHeldCanvases();
 };
 
 } // namespace Experimental
 } // namespace ROOT
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team