gtree.h

Go to the documentation of this file.

#pragma once
 
// gemc
#include <gemc/gqtbuttonswidget/gQtButtonsWidget.h> // Custom toggle button widget
#include <gemc/g4system/g4volume.h>
#include <gemc/gsystem/gvolume.h>
#include <gemc/gbase/gbase.h> // Provides application options/configuration
#include <gemc/goptions/goptions.h>
 
// qt
#include <QWidget>
#include <QTreeWidgetItem>
#include <QColor>
#include <QLabel>
#include <QTextEdit>
#include <QPushButton>
#include <QSlider>
 
class QTimer;
 
// cpp
#include <map>
#include <memory>
 
class G4Ttree_item
{
public:
    explicit G4Ttree_item(G4Volume* g4volume, const GVolume* gvolume = nullptr);
 
private:
    std::string mother;
 
    QColor color;
 
    bool is_visible = true;
 
    int representation = 1; // 0 = wireframe ; 1 = solid; 2 = cloud
 
    double opacity = 1.0;
 
    std::string material;
 
    double mass = 0.0;
 
    double volume = 0.0;
 
    double density = 0.0;
 
    bool recursive = false;
 
    // pygemc descriptor fields (empty when no GVolume descriptor is available)
    std::string solidType;       
    std::string parameters;      
    std::string position;        
    std::string rotation;        
    std::string motherVolume;    
    std::string volDescription;  
 
public:
    [[nodiscard]] std::string get_mother() const { return mother; }
 
    [[nodiscard]] QColor get_color() const { return color; }
 
    [[nodiscard]] bool get_visibility() const { return is_visible; }
 
    [[nodiscard]] int get_representation() const { return representation; }
 
    [[nodiscard]] double get_opacity() const { return opacity; }
 
    [[nodiscard]] double get_mass() const { return mass; }
 
    [[nodiscard]] double get_volume() const { return volume; }
 
    [[nodiscard]] double get_density() const { return density; }
 
    [[nodiscard]] std::string get_material() const { return material; }
 
    [[nodiscard]] bool get_recursive() const { return recursive; }
 
    [[nodiscard]] std::string get_solidType() const { return solidType; }
    [[nodiscard]] std::string get_parameters() const { return parameters; }
    [[nodiscard]] std::string get_position() const { return position; }
    [[nodiscard]] std::string get_rotation() const { return rotation; }
    [[nodiscard]] std::string get_motherVolume() const { return motherVolume; }
    [[nodiscard]] std::string get_volDescription() const { return volDescription; }
 
    void set_recursive(bool recursive) { this->recursive = recursive; }
 
    void set_color(const QColor& c)  { color = c; }
 
    void set_opacity(double opacity) { this->opacity = opacity; }
 
    static std::string vname_from_v4name(std::string v4name);
 
    static std::string system_from_v4name(std::string v4name);
};
 
// map for a single system
using g4tree_map = std::map<std::string, std::unique_ptr<G4Ttree_item>>;
 
class GTree : public QWidget, public GBase<GTree>
{
    Q_OBJECT
 
public:
    explicit GTree(const std::shared_ptr<GOptions>& gopt,
                   std::unordered_map<std::string, G4Volume*> g4volumes_map,
                   std::unordered_map<std::string, const GVolume*> gvolumes_map = {},
                   QWidget* parent = nullptr);
 
    GTree(const GTree&) = delete;
 
    GTree& operator=(const GTree&) = delete;
 
private:
    std::map<std::string, g4tree_map> g4_systems_tree; // map of systems
 
    std::unordered_map<std::string, const GVolume*> gvolumes_map;
 
    QTreeWidget* treeWidget = nullptr;
 
    // right-side panel
    QWidget* rightPanel = nullptr;
 
    QWidget* bottomPanel = nullptr; // appears only when an item is selected
 
    GQTButtonsWidget* styleButtons;  // left bar buttons
 
    // info labels inside bottomPanel
    QLabel* typeLabel = nullptr;         
    QLabel* daughtersLabel = nullptr;    
    QLabel* nameLabel = nullptr;         
    QLabel* materialLabel = nullptr;     
    QLabel* massLabel = nullptr;         
    QLabel* volumeLabel = nullptr;       
    QLabel* densityLabel = nullptr;      
    QLabel* solidTypeLabel = nullptr;    
    QTextEdit* parametersLabel = nullptr; 
    QLabel* positionLabel = nullptr;     
    QLabel* rotationLabel = nullptr;     
    QLabel* motherLabel = nullptr;       
    QLabel* descriptionLabel = nullptr;  
 
    QSlider* opacitySlider = nullptr;
 
    QLabel*  opacityLabel  = nullptr;
 
    QPushButton* inspectButton = nullptr;
 
    QPushButton* drawOverlapsButton = nullptr;
 
    void build_tree(std::unordered_map<std::string, G4Volume*> g4volumes_map);
 
    void populateTree();
 
    void set_visibility(const std::string& fullName, bool visible);
 
    void set_color(const std::string& fullName, const QColor& c);
 
    void set_opacity(const std::string& volumeName, double opacity);
 
    QWidget* right_widget();
 
    int get_ndaughters(QTreeWidgetItem* item) const;
 
    G4Ttree_item* findTreeItem(const std::string& fullName);
 
    std::string current_volume_name;
 
    // Twinkle animation state
    QTimer*     twinkleTimer       = nullptr;
    int         twinkleTick        = 0;
    QColor      twinkleSavedColor;
    double      twinkleSavedOpacity = 1.0;
    std::string twinkleVolumeName;
 
    void centreTwinkle();
 
private slots:
    void onItemChanged(QTreeWidgetItem* item, int column);
 
    void onColorButtonClicked();
 
    void onTreeItemClicked(QTreeWidgetItem* item, int column);
 
    void onCurrentItemChanged(QTreeWidgetItem* current, QTreeWidgetItem* previous);
 
    void changeStyle();
 
    void onOpacitySliderChanged(int value);
 
    void inspectVolume();
 
    void drawOverlapsWarning();
 
    void onTwinkleStep();
};