RAPID modules & program files

// Loads a program into a task (synchronous)
void LoadProgram(string task, string programPath, RapidProgramLoadMode loadMode = RapidProgramLoadMode.Add);

// Saves the program of a task to the file system of the controller (synchronous)
void SaveProgram(string task, string path);

// Sets the routine the program pointer moves to when it is reset (synchronous)
void SetEntryPoint(string task, string routine);

// Renames the program of a task (synchronous)
void SetProgramName(string task, string name);

// Unloads the program of a task (synchronous)
void UnloadProgram(string task);

public class RapidProgramInfo {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidProgramInfo" data-throw-if-not-resolved="false"></xref> class
    public RapidProgramInfo()
 
    // Routine the program pointer moves to when it is reset, null when the controller did not report it
    public string EntryPoint { get; set; }
 
    // Name of the program, null when the controller did not report it
    public string Name { get; set; }
 
    // Returns a string representation of this program
    public override string ToString()
}

public enum RapidProgramLoadMode {
 
    // Keep the modules already loaded and add the ones of the program
    Add = 0
 
    // Replace everything the task holds with the program
    Replace = 1
}

// Gets the file a module came from and the properties declared on it (synchronous)
RapidModuleInfo GetModule(string task, string module);

// Gets the counter the controller increments whenever a module changes (synchronous) Comparing it with what a previous reading gave is cheaper than fetching the source again to find out that nothing changed.
int GetModuleChangeCount(string task, string module);

// Gets how many lines and columns the source of a module holds (synchronous) This is what it takes to ask for the whole of it with Int32%2cSystem.Int32).
RapidModuleExtension GetModuleExtension(string task, string module);

// Gets the declaration the controller finds at a position of a module (synchronous)
RapidModuleSymbol GetModuleSymbol(string task, string module, int row, int column);

// Gets the source of a module (synchronous)
RapidModuleText GetModuleText(string task, string module);

// Gets a range of the source of a module (synchronous)
string GetModuleTextRange(string task, string module, int startRow, int startColumn, int endRow, int endColumn);

// Gets the modules loaded into a task (synchronous)
RapidModuleItem[] GetModules(string task);

// Gets which of the requested properties may be declared on a module (synchronous)
RapidModuleAttribute[] GetPossibleModuleAttributes(string task, string module, params RapidModuleAttribute[] attributes);

// Saves a module to the file system of the controller (synchronous)
void SaveModule(string task, string module, string name, string path);

// Finds where a piece of text sits in the source of a module (synchronous)
RapidTextPosition SearchModuleText(string task, string module, string text, int startRow = 1, int startColumn = 1);

// Replaces the whole source of a module (synchronous)
void SetModuleText(string task, string module, string text);

// Writes text into a range of the source of a module (synchronous)
RapidSetTextRangeResult SetModuleTextRange(string task, string module, RapidTextReplaceMode replaceMode, RapidTextQueryMode queryMode, int startRow, int startColumn, int endRow, int endColumn, string text);

public class RapidModuleItem {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidModuleItem" data-throw-if-not-resolved="false"></xref> class
    public RapidModuleItem()
 
    // Name of the module, for example "MainModule"
    public string Name { get; set; }
 
    // Returns a string representation of this module
    public override string ToString()
 
    // Whether the module belongs to the program or to the system
    public RapidModuleType Type { get; set; }
}

public class RapidModuleInfo : RapidModuleItem {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidModuleInfo" data-throw-if-not-resolved="false"></xref> class
    public RapidModuleInfo()
 
    // Number of properties declared on the module
    public int AttributeCount { get; }
 
    // Properties declared on the module, empty when it declares none
    public RapidModuleAttribute[] Attributes { get; set; }
 
    // Name of the file the module was loaded from, for example "MainModule.mod"
    public string FileName { get; set; }
}

public class RapidModuleText {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidModuleText" data-throw-if-not-resolved="false"></xref> class
    public RapidModuleText()
 
    // Counter the controller increments whenever the module changes, null when it did not report it
    public int? ChangeCount { get; set; }
 
    // Length the controller declares for the module, null when it did not report it.
    // 
    // <p>This is the size the controller reserves for the module and not the length of
    // <xref href="UnderAutomation.ABB.Rws.Data.RapidModuleText.Text" data-throw-if-not-resolved="false"></xref>, so the two normally differ.</p>
    public int? DeclaredLength { get; set; }
 
    // Source of the module
    public string Text { get; set; }
 
    // Returns a string representation of this module source
    public override string ToString()
}

public class RapidModuleExtension {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidModuleExtension" data-throw-if-not-resolved="false"></xref> class
    public RapidModuleExtension()
 
    // Counter the controller increments whenever the module changes, null when it did not report it
    public int? ChangeCount { get; set; }
 
    // Number of lines the module holds, null when the controller did not report it
    public int? LineCount { get; set; }
 
    // Length of the longest line of the module, null when the controller did not report it
    public int? MaxColumnCount { get; set; }
 
    // Returns a string representation of this extension
    public override string ToString()
}

public class RapidSetTextRangeResult {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidSetTextRangeResult" data-throw-if-not-resolved="false"></xref> class
    public RapidSetTextRangeResult()
 
    // Counter the controller incremented for the change, null when it did not report it
    public int? ChangeCount { get; set; }
 
    // Whether the change renamed the module
    public bool ModuleRenamed { get; set; }
 
    // Name the module now has, empty when the change did not rename it
    public string NewModuleName { get; set; }
 
    // Returns a string representation of this result
    public override string ToString()
}

public class RapidTextPosition {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidTextPosition" data-throw-if-not-resolved="false"></xref> class
    public RapidTextPosition()
 
    // Column of the position, 0 when the search found nothing
    public int Column { get; set; }
 
    // Whether the position points at something, which it does not when a search found nothing
    public bool Found { get; }
 
    // Line of the position, 0 when the search found nothing
    public int Row { get; set; }
 
    // Returns a string representation of this position
    public override string ToString()
}

public enum RapidModuleType {
 
    // A module of the program, saved and loaded with it
    ProgramModule = 1
 
    // A module of the system, which survives loading another program
    SystemModule = 2
 
    // The controller reported a type this library does not know
    Unknown = 0
}

public enum RapidModuleAttribute {
 
    // The source of the module is encoded and cannot be read back
    Encoded = 2
 
    // Execution may not step into the routines of the module
    NoStepIn = 4
 
    // The source of the module may not be displayed
    NoView = 3
 
    // The module may not be changed
    ReadOnly = 6
 
    // The module belongs to the system rather than to the program
    SystemModule = 1
 
    // The controller reported an attribute this library does not know
    Unknown = 0
 
    // The source may be displayed but not changed
    ViewOnly = 5
}

public enum RapidTextReplaceMode {
 
    // Insert the new text after the range, leaving it in place
    After = 0
 
    // Insert the new text before the range, leaving it in place
    Before = 1
 
    // Replace the range with the new text
    Replace = 2
}

public enum RapidTextQueryMode {
 
    // Apply the change even when it invalidates the program pointer
    Force = 0
 
    // Apply the change only when the program pointer survives it
    Try = 1
}

// Gets the errors the controller found while linking the program of a task (synchronous)
RapidBuildError[] GetBuildErrors(string task, int? start = null, int? limit = null);

public class RapidBuildError {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidBuildError" data-throw-if-not-resolved="false"></xref> class
    public RapidBuildError()
 
    // Column the error was found at, null when the controller did not report it
    public int? Column { get; set; }
 
    // Description of the error as the controller worded it
    public string Error { get; set; }
 
    // Numeric identifier of the error, null when the controller did not report it
    public int? ErrorNumber { get; set; }
 
    // Name of the module the error was found in
    public string ModuleName { get; set; }
 
    // Line the error was found at, null when the controller did not report it
    public int? Row { get; set; }
 
    // Returns a string representation of this build error
    public override string ToString()
}

// Gets the breakpoints set in the program of a task (synchronous)
RapidBreakpoint[] GetBreakpoints(string task, int? start = null, int? limit = null);

// Sets a breakpoint at a position of a module (synchronous)
RapidBreakpoint SetBreakpoint(string task, string module, int row, int column);

public class RapidBreakpoint {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidBreakpoint" data-throw-if-not-resolved="false"></xref> class
    public RapidBreakpoint()
 
    // Column the breakpoint ends at, null when the controller did not report it
    public int? EndColumn { get; set; }
 
    // Line the breakpoint ends at, null when the controller did not report it
    public int? EndRow { get; set; }
 
    // Name of the module the breakpoint sits in, null when the controller did not report it
    public string ModuleName { get; set; }
 
    // Column the breakpoint starts at, null when the controller did not report it
    public int? StartColumn { get; set; }
 
    // Line the breakpoint starts at, null when the controller did not report it
    public int? StartRow { get; set; }
 
    // Returns a string representation of this breakpoint
    public override string ToString()
}

// Gets every motion instruction of the system whose position can be rewritten to where the robot currently stands, wherever in whichever task it sits (synchronous)
RapidModifiablePositionItem[] GetAllModifiablePositions();

// Gets how many motion instructions of a range can have their position rewritten to where the robot currently stands (synchronous)
RapidModifiablePositions GetModifiablePositions(string task, string module, int startRow, int startColumn, int endRow, int endColumn);

// Rewrites the positions of every motion instruction of the system that can be rewritten, to where the robot currently stands (synchronous)
void ModifyAllPositions(bool checkLimits = true, bool checkDeactivatedAxes = true);

// Rewrites the positions of the motion instructions of a range to where the robot currently stands (synchronous) This is the teaching gesture: jog the robot where it should go, then write that position back into the program.
void ModifyPosition(string task, string module, int startRow, int startColumn, int endRow, int endColumn, bool checkLimits = true, bool checkDeactivatedAxes = true, bool allowDeactivated = false);

public class RapidModifiablePositions {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidModifiablePositions" data-throw-if-not-resolved="false"></xref> class
    public RapidModifiablePositions()
 
    // Column the modifiable range ends at, null when the controller did not report it
    public int? EndColumn { get; set; }
 
    // Line the modifiable range ends at, null when the controller did not report it
    public int? EndRow { get; set; }
 
    // Number of motion instructions of the range whose position can be rewritten
    public int ModifiableLineCount { get; set; }
 
    // Column the modifiable range starts at, null when the controller did not report it
    public int? StartColumn { get; set; }
 
    // Line the modifiable range starts at, null when the controller did not report it
    public int? StartRow { get; set; }
 
    // Returns a string representation of this result
    public override string ToString()
}

public class RapidModifiablePositionItem {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidModifiablePositionItem" data-throw-if-not-resolved="false"></xref> class
    public RapidModifiablePositionItem()
 
    // Column the instruction ends at, null when the controller did not report it
    public int? EndColumn { get; set; }
 
    // Line the instruction ends at, null when the controller did not report it
    public int? EndRow { get; set; }
 
    // Name of the module holding the instruction
    public string ModuleName { get; set; }
 
    // Column the instruction starts at, null when the controller did not report it
    public int? StartColumn { get; set; }
 
    // Line the instruction starts at, null when the controller did not report it
    public int? StartRow { get; set; }
 
    // Name of the task holding the module
    public string TaskName { get; set; }
 
    // Returns a string representation of this instruction
    public override string ToString()
}

// Gets the template the controller suggests for an instruction or a data type: the arguments to write and the values to write them with (synchronous) This is what an editor uses to insert a complete, valid instruction rather than a bare keyword.
RapidInstructionTemplate GetInstructionTemplate(string task, string module, string name, bool isDataType = false, int? row = null, int? column = null, int? parameterNumber = null, int? alternativeNumber = null);

// Gets the parts a RAPID object is made of and where each of them sits in the source (synchronous) Pass the whole span of the object to get its parts; an editor uses this to know where the name, the attributes and the declaration lists of a module begin and end.
RapidObjectChild GetObjectChildren(string task, string module, int startLine, int startColumn, int endLine, int endColumn);

// Gets where one of the lists a RAPID object holds sits in the source: the span of the whole list, and the spans of its first and last elements (synchronous) An editor uses this to jump to the beginning or the end of a list without reading the whole module.
RapidObjectListExtension GetObjectListExtension(string symbolUrl, RapidObjectListType type = RapidObjectListType.Statements);

// Gets the entries of one category of the instruction palette (synchronous)
RapidPalletItem[] GetPallet(string task, int palletNumber, int? start = null, int? limit = null);

// Gets the categories of the instruction palette an editor offers (synchronous)
RapidPalletHeadItem[] GetPalletHeads(string task, int? start = null, int? limit = null);

// Gets the data types the controller suggests for one argument of an instruction (synchronous) An editor uses this to offer only the types that fit where the operator is typing.
RapidPreferredDataTypeItem[] GetPreferredDataTypes(string task, string instruction, string parameter);

// Gets the routine the controller finds called at a position of a module (synchronous)
RapidRoutineInfo GetRoutine(string task, string module, int row, int column);

// Gets the arguments of the routine call found at a position of a module (synchronous)
RapidRoutineArgument[] GetRoutineArguments(string task, string module, int row, int column, int? mark = null, int? limit = null);

public class RapidModuleSymbol {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidModuleSymbol" data-throw-if-not-resolved="false"></xref> class
    public RapidModuleSymbol()
 
    // Name of the type of the symbol, for example "robtarget"
    public string DataType { get; set; }
 
    // Number of array dimensions of the symbol, null when the controller did not report it
    public int? Dimensions { get; set; }
 
    // Whether the symbol is allocated on the heap, null when the controller did not report it
    public bool? Heap { get; set; }
 
    // Whether the declaration is complete, null when the controller did not report it
    public bool? Linked { get; set; }
 
    // Whether the symbol is local to its module, null when the controller did not report it
    public bool? Local { get; set; }
 
    // Name of the declared symbol
    public string Name { get; set; }
 
    // How many times the symbol is referred to, null when the controller did not report it
    public int? ReferenceCount { get; set; }
 
    // How the controller stores the symbol, null when it did not report it
    public int? Storage { get; set; }
 
    // What kind of symbol was declared
    public RapidSymbolType SymbolType { get; set; }
 
    // Path of the symbol, which the symbol resources take
    public string SymbolUrl { get; set; }
 
    // Returns a string representation of this declaration
    public override string ToString()
 
    // Path of the type of the symbol
    public string TypeUrl { get; set; }
 
    // Version the controller stamps on the declaration
    public string Version { get; set; }
}

public class RapidRoutineInfo {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidRoutineInfo" data-throw-if-not-resolved="false"></xref> class
    public RapidRoutineInfo()
 
    // Whether the routine is local to its module, null when the controller did not report it
    public bool? Local { get; set; }
 
    // Name of the routine
    public string Name { get; set; }
 
    // Whether the routine is named, null when the controller did not report it
    public bool? Named { get; set; }
 
    // Number of parameters the routine takes, null when the controller did not report it.
    // 
    // <p>The controller reports -1 when the parameter list is not linked yet.</p>
    public int? ParameterCount { get; set; }
 
    // Whether the routine is a procedure, a function or a trap
    public RapidSymbolType SymbolType { get; set; }
 
    // Path of the routine, which the program pointer resources take
    public string SymbolUrl { get; set; }
 
    // Returns a string representation of this routine
    public override string ToString()
}

public class RapidRoutineArgument {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidRoutineArgument" data-throw-if-not-resolved="false"></xref> class
    public RapidRoutineArgument()
 
    // Which alternative of the parameter this argument fills, null when the controller did not report it
    public int? AlternateArgument { get; set; }
 
    // Type of the argument, for example "num"
    public string DataType { get; set; }
 
    // Column the argument ends at, null when the controller did not report it
    public int? EndColumn { get; set; }
 
    // Line the argument ends at, null when the controller did not report it
    public int? EndRow { get; set; }
 
    // Length of the argument list, null when the controller did not report it
    public int? ListLength { get; set; }
 
    // Position of the argument in the argument list, null when the controller did not report it
    public int? ListNumber { get; set; }
 
    // What the argument is, for example a required argument or a name reference
    public string ObjectType { get; set; }
 
    // Position of the argument in the call, counted from 0
    public int? ParameterNumber { get; set; }
 
    // Column the argument starts at, null when the controller did not report it
    public int? StartColumn { get; set; }
 
    // Line the argument starts at, null when the controller did not report it
    public int? StartRow { get; set; }
 
    // Returns a string representation of this argument
    public override string ToString()
}

public class RapidInstructionTemplate {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidInstructionTemplate" data-throw-if-not-resolved="false"></xref> class
    public RapidInstructionTemplate()
 
    // Number of arguments the controller reported, null when it did not report it
    public int? ArgumentCount { get; set; }
 
    // The suggested arguments
    public RapidInstructionTemplateArgument[] Arguments { get; set; }
 
    // Whether every argument has been reported, null when the controller did not report it
    public bool? Complete { get; set; }
 
    // Index the controller started reporting from, null when it did not report it
    public int? Mark { get; set; }
 
    // Argument the controller suggests selecting first, null when it did not report it
    public int? SelectedParameter { get; set; }
 
    // Returns a string representation of this template
    public override string ToString()
 
    // Version the controller stamps on the template
    public string Version { get; set; }
}

public class RapidInstructionTemplateArgument {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidInstructionTemplateArgument" data-throw-if-not-resolved="false"></xref> class
    public RapidInstructionTemplateArgument()
 
    // Position of the argument, null when the controller did not report it
    public int? ArgumentNumber { get; set; }
 
    // Type of the argument, for example "robtarget"
    public string DataType { get; set; }
 
    // Whether inserting the instruction also needs a declaration to be created for this argument,
    // null when the controller did not report it
    public bool? DeclarationNeeded { get; set; }
 
    // Number of array dimensions of the argument, null when the controller did not report it
    public int? Dimensions { get; set; }
 
    // Whether the suggested symbol is local to its module, null when the controller did not report it
    public bool? Local { get; set; }
 
    // Name of the argument, for example "ToPoint"
    public string Name { get; set; }
 
    // How the suggested symbol is declared, for example "CONST" or "TASK PERS"
    public string ObjectType { get; set; }
 
    // Whether the argument has to be given, null when the controller did not report it
    public bool? Required { get; set; }
 
    // Name of the symbol the argument refers to, empty when the argument is written as a literal
    public string Symbol { get; set; }
 
    // Returns a string representation of this argument
    public override string ToString()
 
    // Value the argument is suggested with, written the way RAPID writes it
    public string Value { get; set; }
}

public class RapidObjectChild {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidObjectChild" data-throw-if-not-resolved="false"></xref> class
    public RapidObjectChild()
 
    // Returns the span of one part by its name, null when the controller did not report it
    public RapidTextRange GetRange(string name)
 
    // What the object is, for example "module"
    public string ObjectType { get; set; }
 
    // Number of parts the controller reported
    public int RangeCount { get; }
 
    // The parts of the object, including the ones it does not hold, whose span is then empty
    public RapidObjectChildRange[] Ranges { get; set; }
 
    // Returns a string representation of this object
    public override string ToString()
}

public class RapidObjectChildRange {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidObjectChildRange" data-throw-if-not-resolved="false"></xref> class
    public RapidObjectChildRange()
 
    // Whether the controller reported a real span for the part, which it does not when the object
    // does not hold it
    public bool IsPresent { get; }
 
    // Name of the part as the controller worded it, for example "data-decl" or "endmod"
    public string Name { get; set; }
 
    // Where the part sits in the source
    public RapidTextRange Range { get; set; }
 
    // Returns a string representation of this part
    public override string ToString()
}

public class RapidObjectListExtension {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidObjectListExtension" data-throw-if-not-resolved="false"></xref> class
    public RapidObjectListExtension()
 
    // Span of the first element of the list
    public RapidTextRange First { get; set; }
 
    // Span of the last element of the list
    public RapidTextRange Last { get; set; }
 
    // Span of the whole list
    public RapidTextRange List { get; set; }
 
    // Returns a string representation of this extension
    public override string ToString()
}

public enum RapidObjectListType {
 
    // The attributes it declares
    Attributes = 8
 
    // The statements of its BACKWARD handler
    BackwardStatements = 1
 
    // The data declarations it holds
    DataDeclarations = 5
 
    // The statements of its ERROR handler
    ErrorStatements = 2
 
    // The parameter declarations it holds
    ParameterDeclarations = 6
 
    // The routine declarations it holds
    RoutineDeclarations = 7
 
    // The statements of the object
    Statements = 0
 
    // The type declarations it holds
    TypeDeclarations = 4
 
    // The statements of its UNDO handler
    UndoStatements = 3
}

public class RapidPalletHeadItem {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidPalletHeadItem" data-throw-if-not-resolved="false"></xref> class
    public RapidPalletHeadItem()
 
    // Name of the category, for example "Motion&amp;Proc."
    public string Name { get; set; }
 
    // Number identifying the category, null when the controller did not report it
    public int? Number { get; set; }
 
    // Returns a string representation of this category
    public override string ToString()
}

public class RapidPalletItem {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidPalletItem" data-throw-if-not-resolved="false"></xref> class
    public RapidPalletItem()
 
    // Alternative of the parameter the entry preselects, null when the controller did not report it
    public int? Alternative { get; set; }
 
    // Instruction the entry inserts
    public string Instruction { get; set; }
 
    // Whether the entry is a language keyword rather than an instruction, null when the controller
    // did not report it
    public int? Keyword { get; set; }
 
    // Name shown for the entry, for example "MoveJ"
    public string Name { get; set; }
 
    // Parameter the entry preselects, null when the controller did not report it
    public int? Parameter { get; set; }
 
    // Returns a string representation of this entry
    public override string ToString()
}

public class RapidPreferredDataTypeItem {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidPreferredDataTypeItem" data-throw-if-not-resolved="false"></xref> class
    public RapidPreferredDataTypeItem()
 
    // Data type of the suggestion
    public string DataType { get; set; }
 
    // Name of the suggestion, for example "signaldi"
    public string Name { get; set; }
 
    // Returns a string representation of this suggestion
    public override string ToString()
}