undoAppST.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <vector>
#include <filesystem>
#include <memory>
#include <unordered_map>
 
// Include TextEditor
#include <TextEditor.h>
 
// Include st2cpp headers
#include "lexer/Lexer.h"
#include "parser/Parser.h"
#include "ast/AST.h"
#include "undoAppSTSemantic.hpp"
#include "undoAppSTOutput.hpp"
#include "undoAppSTSnippet.hpp"
#include "semantic/SemanticAnalyzer.h"
#include "semantic/LibraryDescriptorBuilder.h"
#include "library/LibraryRegistry.h"
#include "semantic/SymbolTable.h"
 
namespace undoApp {
namespace ST {
 
using TranslationUnit = ::TranslationUnit;
using ParseError = ::ParseError;
 
enum class POUType {
   Program,
   FunctionBlock,
   Function
};
 
struct FileNode
{
    std::string name;               
    std::string path;               
    bool isDirectory;               
    std::vector<FileNode> children; 
    bool expanded = false;          
    bool isDragging = false;        
    int role = 0;               
};
 
struct MethodData
{
   std::string name;          
   std::string returnType;    
   std::string variablesText; 
   std::string bodyText;      
   std::string visibility;    
   bool isAbstract = false;   
   bool isFinal = false;      
   bool isOverride = false;   
};
 
struct MethodEditors
{
   std::unique_ptr<TextEditor> variables;
   std::unique_ptr<TextEditor> body;
   float splitterPos = 0.5f;
};
 
struct STDocument
{
   std::string path;                    
   POUType pouType = POUType::Program;  
   std::string pouName;                 
   std::string functionReturnType;      
   std::string pouVariablesText;        
   std::string pouBodyText;             
   std::vector<MethodData> methods;     
   float splitterPos = 0.5f;            
   std::string activeTab;               
};
 
struct SourceSegment
{
   int fullStart = 0;        
   int fullEnd = 0;          
   bool isVariables = false; 
   std::string methodName;   
};
 
class STApp
{
public:
   static STApp& getInstance();
 
   bool initialize();
 
   void shutdown();
 
   void registerPanels();
 
   // ============================================================================
   // Panel rendering methods
   // ============================================================================
 
   void beginEditorFrame();
 
   void renderDocument();
 
   void endEditorFrame();
 
   void renderOutputPanel();
 
   void renderOutlinePanel();
 
   void renderWorkspacePanel();
 
   void renderFileTree(FileNode& node);
 
   // ============================================================================
   // Workspace and file management
   // ============================================================================
 
   void loadWorkspace(const std::string& path);
 
   void openWorkspaceDialog();
 
   void createNewFile(const std::string& parentPath, const std::string& name);
 
   void createNewFolder(const std::string& parentPath, const std::string& name);
 
   void deleteFile(const std::string& path);
 
   void renameFile(const std::string& oldPath, const std::string& newName);
 
   void moveFile(const std::string& sourcePath, const std::string& destDir);
 
   void renameFileTo(const std::string& path);
 
   void saveCurrentFile();
 
   bool hasUnsavedChanges() const { return m_isDirty; }
 
   void openFile(const std::string& path);
 
   void closeFile();
 
   bool handleKeyboardShortcuts();
 
   // ============================================================================
   // Editor and parsing methods
   // ============================================================================
 
   std::string generateSTFile();
 
   std::string generateSTFileWithMap(std::vector<SourceSegment>& outSegments);
 
   void refreshSemanticHighlighting();
 
   const SourceSegment* segmentForLine(int fullLine) const;
 
   // ============================================================================
   // Go-to-declaration
   // ============================================================================
 
   static bool identifierAt(const TextEditor& editor, int line, int col, std::string& outName);
 
   const Declaration* findDeclaration(const std::string& name, const std::string& scope) const;
 
   static int columnOfName(const std::vector<std::string>& srcLines, int line, const std::string& name);
 
   void revealGeneratedLine(int fullLine, int col, int tokenLength = 0);
 
   STDocument takeDocument();
 
   void setDocument(const STDocument& doc);
 
   bool revealMethodTab(const std::string& methodName);
 
   void requestTabSelection(const std::string& tabName);
 
   void requestAddMethodDialog();
 
   bool consumeAddMethodDialogRequest();
 
   bool revealDeclaration(const Declaration& decl);
 
   void handleNavigationInput(const char* id, TextEditor& editor);
   void applyPendingJump();
 
   void showIdentifierTooltip(TextEditor& editor);
 
   // ============================================================================
   // Unsaved-changes handling
   // ============================================================================
 
   void updateDirtyState();
 
   void requestOpenFile(const std::string& path);
 
   void openMethodOf(const std::string& filePath, const std::string& methodName);
 
   void renderDirtyPrompt();
 
   void renderJumpPopup();
 
   // ============================================================================
   // Workspace declaration index (cross-file navigation)
   // ============================================================================
 
   struct WorkspaceMethod
   {
      std::string name;
      std::string returnType;
      int line = 0;
   };
 
   struct WorkspaceDeclaration
   {
      std::string file;  
      int line = 0;      
      std::string scope; 
      SymCategory category = SymCategory::Unresolved;
      std::string typeText;
      std::string kindText;
      std::string pouName;
   };
 
   void ensureWorkspaceIndex();
 
   void ensureProjectRegistry();
 
   void invalidateWorkspaceIndex(const std::string& path);
 
   std::vector<WorkspaceDeclaration> findWorkspaceDeclarations(const std::string& name) const;
 
   void indexSTFile(const std::string& path,
                    std::unordered_map<std::string, std::vector<WorkspaceDeclaration>>& outDecls) const;
 
   void setupEditors();
 
   void validateAndParse();
 
   void compile();
 
   // ============================================================================
   // Error mapping helpers
   // ============================================================================
 
   static int countLines(const std::string& text);
 
   void addOutput(OutSeverity severity, std::string text);
 
   void setErrorMarkers();
 
   // ============================================================================
   // METHOD management (FUNCTION_BLOCK only)
   // ============================================================================
 
   void renderSplitEditor(TextEditor& varEditor,
                          TextEditor& bodyEditor,
                          float& splitterPos,
                          const char* varLabel,
                          const char* bodyLabel,
                          const char* varId,
                          const char* bodyId);
 
   MethodEditors& getOrCreateMethodEditors(MethodData& method);
 
   void syncMethodEditorsToData();
 
   void addMethod(const std::string& name, const std::string& returnType);
 
   void deleteMethod(const std::string& name);
 
   int findMethodIndex(const std::string& name) const;
 
   void resetMethodState();
 
private:
   // ============================================================================
   // Generated-source layout
   // ============================================================================
 
   TextEditor* editorForSegment(const SourceSegment& segment) const;
   // ============================================================================
   // Line mapping for methods
   // ============================================================================
   // Superseded by SourceSegment/m_sourceMap, which is filled while the file is
   // generated and therefore cannot drift from the text the parser saw.
   struct MethodLineInfo
   {
      std::string name;
      int startLine;
      int endLine;
   };
 
   // ============================================================================
   // Member variables
   // ============================================================================
 
   bool m_initialized = false;             
   std::string m_workspacePath;            
   FileNode m_rootNode;                    
   std::string m_currentFilePath;          
   std::string m_currentFileContent;       
   std::vector<OutputLine> m_outputLines; 
   bool m_showGeneratedDump = false;
   OutputFilter m_outputFilter;
   char m_outputSearch[256] = {};
   size_t m_outputLinesShown = 0;
 
   std::unique_ptr<TextEditor> m_variablesEditor; 
   std::unique_ptr<TextEditor> m_bodyEditor;      
 
   std::string m_pouName;                
   POUType m_pouType = POUType::Program; 
 
   std::unique_ptr<TranslationUnit> m_ast; 
   std::vector<ParseError> m_errors;       
 
   std::vector<SourceSegment> m_sourceMap; 
 
   std::vector<std::string> m_srcLines;     
 
   std::unique_ptr<st2cpp::semantic::SemanticInfo> m_semantic;
 
   DeclarationIndex m_declarations;
 
   // ============================================================================
   // Unsaved-changes state
   // ============================================================================
 
   bool m_showTooltips = false;   
   bool m_isDirty = false;        
   int m_ignoreChangeFrames = 0;  
   bool m_showDirtyPrompt = false;
   std::string m_pendingOpenPath; 
 
   // ============================================================================
   // Workspace declaration index
   // ============================================================================
 
   std::unordered_map<std::string, std::vector<WorkspaceDeclaration>> m_workspaceDecls;
   bool m_workspaceIndexValid = false;
 
   std::unique_ptr<st2cpp::library::LibraryRegistry> m_projectRegistry;
 
   mutable std::unordered_map<std::string, std::vector<WorkspaceMethod>> m_workspaceMethods;
 
   std::string m_pendingTabAfterOpen;
 
   // ============================================================================
   // Pending cross-file navigation
   // ============================================================================
 
   std::string m_pendingJumpName; 
   std::vector<WorkspaceDeclaration> m_jumpCandidates;
   std::string m_jumpCandidateName;
   bool m_showJumpPopup = false;  
 
    // ============================================================================
    // METHOD management
    // ============================================================================
 
   std::vector<MethodData> m_methods; 
   std::string m_currentContext;      
   std::string m_pouVariablesText;    
   std::string m_pouBodyText;         
 
   std::string m_activeTab;                                        
 
   std::string m_pendingTabSelection;                              
   bool m_pendingSelectPOU = false;                                
   std::unordered_map<std::string, MethodEditors> m_methodEditors; 
 
   // ============================================================================
   // Popup states
   // ============================================================================
 
   bool m_showNewFilePopup = false;
   bool m_showNewFolderPopup = false;
   bool m_showRenamePopup = false;
   bool m_showNewPOUPopup = false;
   bool m_showAddMethodPopup = false;           
   bool m_addMethodDialogPending = false;       
 
   // ============================================================================
   //  Member completion
   //
   //  Triggered by typing '.' after an identifier that denotes a function block
   //  instance. Typing keeps going to the editor, so the list filters itself as
   //  the prefix grows; only the navigation and confirmation keys are captured.
   // ============================================================================
 
   TextEditor* m_completionEditor = nullptr;
 
   std::vector<MemberAccess> m_completionCandidates;
 
   int m_completionSelected = 0;   
   std::string m_completionPrefix;  
   std::string m_completionObject;  
 
   struct CompletionSpot
   {
      int line = -1;
      int column = -1;
   };
  TextEditor* m_parameterPickerEditor = nullptr;
  bool m_completionIsParameterList = false;
  CompletionSpot m_completionDismissed;
   bool m_completionDismissedValid = false;
   int m_completionLine = -1;
   int m_completionColStart = 0;
   int m_completionColEnd = 0;
 
  ImVec2 m_completionRectMin = ImVec2(0.0f, 0.0f);
  ImVec2 m_completionRectMax = ImVec2(0.0f, 0.0f);
  ImVec2 m_completionEditorMin = ImVec2(0.0f, 0.0f);
   ImVec2 m_completionEditorMax = ImVec2(0.0f, 0.0f);
   ImVec2 m_completionCursorScreen = ImVec2(0.0f, 0.0f);
 
   int m_completionScroll = 0;
 
   int m_completionPageSize = 8;
 
   void updateMemberCompletion(const char* id, TextEditor& editor, bool editorHasKeyboard);
   void clearMemberCompletion();
   void dismissMemberCompletion();
   void moveMemberCompletion(int delta);
   void moveMemberCompletionByPage(int pages);
   void acceptMemberCompletion();
   void renderMemberCompletion();
   ImGuiKey handleMemberCompletionKeys();
 
   std::string methodScopeAtLine(int line) const;
 
   st2cpp::semantic::ScopeId scopeIdForLine(int line) const;
   // ============================================================================
   //  Signature help
   //
   //  The parameter list of the call the cursor is inside, with the argument
   //  being written highlighted. Recomputed from the text like the member list,
   //  so it follows the cursor across a multi-line call and closes at the ')'.
   // ============================================================================
 
   TextEditor* m_signatureEditor = nullptr;
   CallSignature m_signature;   
   CallSite m_signatureCall;    
   int m_signatureArgument = 0; 
 
   CompletionSpot m_signatureDismissed;
   bool m_signatureDismissedValid = false;
 
  ImVec2 m_signatureRectMin = ImVec2(0.0f, 0.0f);
  ImVec2 m_signatureRectMax = ImVec2(0.0f, 0.0f);
  ImVec2 m_signatureCursorScreen = ImVec2(0.0f, 0.0f);
   ImVec2 m_signatureEditorMin = ImVec2(0.0f, 0.0f);
   ImVec2 m_signatureEditorMax = ImVec2(0.0f, 0.0f);
 
   bool m_signatureArgumentEmpty = false;
 
   void updateSignatureHelp(const char* id, TextEditor& editor, bool editorHasKeyboard);
   void clearSignatureHelp();
   void dismissSignatureHelp();
   void renderSignatureHelp();
   ImGuiKey handleSignatureHelpKeys();
 
   void renderParameterNameHint(const char* id, TextEditor& editor);
 
   void runTranspiler();
 
   // ============================================================================
   //  Statement completion
   //
   //  Typing the first letters of a statement offers the statements that start
   //  that way, and accepting one writes the whole skeleton with the caret on the
   //  part still to be filled in.
   //
   //  The state is kept apart from the member completion's. The two can be
   //  answering about the same word and only one of them can be on screen, so
   //  each has to be able to tell that the other is up.
   // ============================================================================
 
   TextEditor* m_snippetEditor = nullptr;   
 
   std::vector<StatementSnippet> m_snippetCandidates; 
 
   std::vector<std::vector<int>> m_snippetMatchMask;
 
   int m_snippetSelected = 0;         
   int m_snippetScroll = 0;           
   std::string m_snippetPrefix;       
   bool m_snippetInVariables = false; 
 
   int m_snippetLine = -1;
   int m_snippetColStart = 0;
   int m_snippetColEnd = 0;
 
   CompletionSpot m_snippetDismissed;
   bool m_snippetDismissedValid = false;
 
   ImVec2 m_snippetRectMin = ImVec2(0.0f, 0.0f);
   ImVec2 m_snippetRectMax = ImVec2(0.0f, 0.0f);
   ImVec2 m_snippetCursorScreen = ImVec2(0.0f, 0.0f);
   ImVec2 m_snippetEditorMin = ImVec2(0.0f, 0.0f);
   ImVec2 m_snippetEditorMax = ImVec2(0.0f, 0.0f);
 
   void updateStatementCompletion(const char* id, TextEditor& editor, bool editorHasKeyboard, bool inVariables);
   void clearStatementCompletion();
   void dismissStatementCompletion();
   void moveStatementCompletion(int delta);
   void moveStatementCompletionByPage(int pages);
   void acceptStatementCompletion();
   void renderStatementCompletion();
   ImGuiKey handleStatementCompletionKeys();
 
   bool statementCompletionOpen() const { return m_snippetEditor != nullptr && !m_snippetCandidates.empty(); }
 
   void invalidateSemanticTokens();
 
   static constexpr ImGuiWindowFlags kMemberCompletionWindowFlags =
       ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoSavedSettings |
       ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoNavFocus |
       ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse;
 
   static constexpr ImGuiWindowFlags kSignatureHelpWindowFlags = kMemberCompletionWindowFlags;
 
  void claimOverlayNavigationKeys();
 
  bool anyOverlayOpen() const;
 
  bool buildParameterPicker(TextEditor& editor, const std::vector<std::string>& lines,
                            const TextEditor::Coordinates& cursor);
 
   bool m_showDeleteMethodConfirmation = false; 
   POUType m_newPOUType = POUType::Program;
   std::string m_newPOUName;
   std::string m_newItemName;
   std::string m_newItemParent;
   std::string m_renamePath;
   float m_splitterPos = 0.5f;      
   bool m_splitterDirty = false;     
   std::string m_functionReturnType;
 
   // Method creation popup state
   std::string m_newMethodName;
   std::string m_newMethodReturnType;
   std::string m_newMethodVisibility;
   std::string m_methodToDelete;
 
   // ============================================================================
   // Delete confirmation state
   // ============================================================================
 
   bool m_showDeleteConfirmation = false; 
 
   bool m_showWorkspaceDialog = false;
   char m_workspaceDialogPath[1024] = {};
   std::string m_deletePendingPath;       
 
   // ============================================================================
   // Drag and drop state
   // ============================================================================
 
   std::string m_draggedItemPath;
   bool m_isDragging = false;
   std::string m_dropTargetPath;
   bool m_showDropIndicator = false;
};
 
} // namespace ST
} // namespace undoApp