RBC Developer Manual
  • Architecture and conventions
    • Building this manual
      • Dependencies
      • Targets
      • Generated files and validation
      • Doxygen callback declaration compatibility
      • Theme and publishing
      • Sidebar hierarchy
    • Implementation overview
      • Supporting modules
      • Lifetime and callbacks
      • Object interaction
      • Core record index
    • Header structure
      • Record coverage
    • Package loading and stubs
      • Loader sequence
      • Interpreter state and registration
      • Failure boundaries
      • Client stubs and ABI maintenance
      • Loader callbacks versus package initialization
    • Package initialization C reference
      • Private registration helpers
      • Windows loader wrappers
    • C calling conventions
      • Writing parameter contracts
    • C documentation conventions
      • Where comments belong
      • C function names
      • Contract contents
      • Migration and review
      • Navigation and groups
      • Extraction checks for declarations and platform branches
      • Contract and member comment placement
      • File headers
  • Vectors and numerical operations
    • Vector ownership and notifications
      • Module boundaries
      • Records, names and storage
      • Storage replacement versus in-place modification
      • Read-only state
      • Observers and callback lifetime
      • Changed intervals and extrema
      • Graph consumers
    • Vector client C reference
      • Types
      • Observers and range access
      • Private update helpers
    • Vector C API and storage primitives
      • Public versus private entry points
      • Registry and creation
      • Lookup and borrowed views
      • Resizing, resetting and copying
      • Protection, publication and destruction
      • Callback boundaries and ownership commits
      • Post-callback checks and publication
      • Observer snapshots and interval scope
      • Incremental extrema maintenance
      • Variable-trace errors use Tcl object results
      • Names, namespaces and access surfaces
      • Creation parsers and bounded index strings
    • Vector storage public C reference
    • Vector storage private C reference
      • Parameter and ownership conventions
      • Data records and member contracts
    • Vector names, indices and mapped arrays
      • Names and selections
      • Mapped arrays
      • Value objects
      • Index parsing branches and caller obligations
      • Finite extrema and low-level writes
      • Literal registry lookup and temporary names
    • Vector access C reference
      • Scalar complex helpers
    • Vector instance commands and binary input
      • Dispatch and mutation boundaries
      • Control operations and array access
      • Append and replacement
      • Sorting
      • Binary channel input
      • Vector ensemble and registry operations
        • Ensemble argument and callback contracts
        • Creation and reuse
        • Named expression results
        • Rename, destruction and enumeration
      • Shared command-helper ownership
        • Output identity and partial creation
        • Permutation mechanics
    • Vector command C reference
      • Data records and member contracts
      • Implementation selectors
    • Vector indexed edits and rearrangement
      • Mutation boundaries
      • Indexed access and deletion
      • Length and offset
      • Copying, interleaving and splitting
      • Population and source aliasing
      • Paired-vector simplification
        • Distance and subdivision
        • Commit and observer lifetime
    • Vector edit C reference
    • Vector queries and numerical generators
      • Arithmetic returns values
      • Ranges and searches
      • Normalization and random values
      • Sequence length and endpoint policy
      • Scalar helper contracts
    • Vector numerical operation C reference
    • Vector expression evaluation
      • Entry points and result ownership
      • Parsing and input snapshots
      • Real and complex temporaries
      • Assignment and named creation
      • Map callback boundary
    • Vector expression C reference
      • Registry initialization
    • Expression parser and adapter internals
      • Parser state and precedence
      • Token recognition and substitutions
      • Temporary storage and type changes
      • Function adapters and validation
      • Scalar conversion and operand reuse
      • Parser argument and completion contracts
      • Adapter data and temporary failure states
      • Registry value ownership
    • Expression engine internal C reference
      • Data records and member contracts
      • Implementation selectors
    • Expression reductions and scalar kernels
      • Selection, finite samples and ownership
      • Implemented reduction formulas
      • Real order statistics and normalization
      • Higher moments and compatibility
      • Complex elementary functions
      • Scalar ownership and dispatch
      • Return values and mutation boundaries
      • Full-storage extrema inputs
    • Expression numerical C reference
    • FFT workspace and output ownership
      • Dispatch and validation
      • Transform length and normalization
      • Workspace and commit sequence
      • Callback lifetime and reentry
      • Frequency and window generators
      • Internal helper boundaries
      • Count and ownership conventions
    • FFT and generator C reference
      • Implementation helpers
    • Spline interpolation and graph smoothing
      • Coordinate and parameter interfaces
      • Cartesian kernels
      • Parametric paths
      • Tcl vector ownership
      • Graph smoothing
      • Private helper contracts
      • Choosing and calling an entry point
      • Command and graph boundaries
    • Spline C reference
      • Implementation helpers
      • Data records and member contracts
  • Graphs and components
    • Graph widget
      • Graph lifecycle and redisplay
        • Creation and ownership
        • Widget option transactions
        • Redraw requests and dirty state
        • Layout and cancellation
        • Frame drawing and presentation
        • Destruction
        • Contributor checks
        • Widget commands and geometry queries
        • Screen composition and snapshot capture
        • Construction helpers and notification ownership
        • Windows metafile layout and ownership
      • Graph lifecycle C reference
        • Widget ownership and layout records
        • Shared entry points
        • Internal lifecycle callbacks
        • Widget option transactions
        • Commands and screen composition
        • Construction and redraw support
        • Windows metafile packaging
        • Data records and member contracts
        • Implementation selectors
    • Axes
      • Axis ownership and commands
        • Names, references and margin membership
        • Configuration boundary
        • Dispatch and bindings
        • Cleanup and failure recovery
        • Option transaction internals
          • Transaction argument contracts
          • Parsing policies
          • Expression evaluation boundary
        • Ranges and tick generation
          • Linear sweep policy
          • Logarithmic sweep policy
          • Explicit arrays and ownership
          • Numerical mapping boundary
        • Labels, geometry and presentation
          • Formatter callback boundary
          • Geometry and picking
          • Screen and document output
          • Limit annotations and remaining differences
        • Margin layout and aspect
        • Queries and freshness
        • Scrolling state and local views
        • Notifications and delivery
      • Axis control C reference
        • Registry and lifetime
        • Configuration entry points
        • Commands and bindings
        • Option transaction internals
        • Ranges, coordinates and tick sweeps
        • Labels, geometry and presentation
        • Layout, queries, scrolling and notifications
        • Data records and member contracts
        • Implementation selectors
    • Coordinate mapping
      • Axes, mapping and track viewports
        • Preparing geometry
        • Coordinate conventions
        • Full tracks and visible tracks
        • Temporary export layouts
        • Useful regression coverage
        • Axis-space helper contracts
      • Coordinate mapping C reference
        • Data and screen coordinates
        • Track layout and viewport scopes
        • Data records and member contracts
    • Elements
      • Element data and dispatch
        • Data slots
        • Staging and commit
        • Updates and invalidation
        • Type dispatch and display order
        • Destruction
        • Synchronous layout before idle notifications
        • Transaction records and failure rules
        • Original arguments and repeated options
        • Retained coordinate representations
        • Callback boundaries
        • Parsing, allocation and extrema
        • Notification metadata and synchronous refresh
        • Value-label formatting
        • Closest-result source values and traces
        • Registry and display-list ownership
        • Option initialization and resource lifetime
        • Normal, active and export passes
        • Command dispatch and query domains
        • Binding tokens
        • Mutation boundaries
        • Closest-search phases
        • Line-family geometry ownership
          • Mapped points and discontinuities
          • Reset versus destruction
        • Line mapping pipeline
          • Smoothing, gaps and symbol selection
          • Clipping and palette grouping
          • Source extents
        • Line-family picking and metadata
          • Point and trace metrics
          • Source picking after reduction
          • Collect before publishing
          • Screen stroke adapters
        • Line symbols and output dispatch
          • Symbol selection and fallback
          • Fills and labels
        • Line configuration and continuous-run smoothing
          • Ordinary and parametric resampling
          • Scalar adapters and ownership
        • Pen, palette and error-geometry boundaries
      • Element data C reference
        • Element ownership, data and picking records
        • Data slots
        • Common data transactions
        • Type dispatch signatures
        • Configuration transaction internals
        • Data observation and value presentation
        • Lifecycle and display dispatch
        • Commands and binding tags
        • Line geometry and resource lifecycle
        • Line mapping pipeline
        • Line picking and stroke dispatch
        • Line symbol and output dispatch
        • Line configuration and smoothing
        • Shared error-bar geometry
        • Data records and member contracts
        • Implementation selectors
    • Pens
      • Pens and style palettes
        • Named and embedded pens
        • Configuration and redraw
        • Palette ownership
        • Selecting a style
        • Resource teardown
        • Creation and command boundaries
        • Candidate palettes and default ranges
      • Pen and palette C reference
        • Pen ownership and palette records
        • Pen lifecycle callback types
        • Named pen references
        • Graph resource teardown
        • Element palettes
        • Named pen implementation
        • Palette implementation
        • Data records and member contracts
    • Bars
      • Bar elements
        • Records and ownership
        • Creation and configuration
        • Grouping keys and passes
        • Placement formulas
        • Data limits and error translations
        • Screen geometry, ownership and output
        • Palette grouping and active geometry
        • Screen and export dispatch
        • Value labels and callbacks
        • Cleanup and font changes
        • Array and coordinate contracts
        • Resource and output contracts
      • Bar element C reference
        • Bar grouping state
        • Configuration and pens
        • Grouping and placement
        • Geometry and lifetime
        • Screen drawing and document output
    • Area fills and error bands
      • Area fills and error bands
        • Resources and configuration
        • Ordinary area geometry
        • Error-band geometry
        • Drawing, export and cleanup
        • Pattern and tile transaction details
        • Adjacent scalar and symbol parsing
      • Line fill C reference
        • Configuration and resource transactions
    • Decimation
      • Line decimation and source identity
        • Eligibility and density
        • Mapping paths and fallback
        • Persistent cache maintenance
        • Picking, symbols and exports
        • Cache state and borrowed storage
          • Growth and prefix proof
          • Bucket and range contracts
        • Converted source representations
        • Pixel-bucket output ownership
      • Line decimation C reference
        • Source summaries and bucket searches
        • Data records and member contracts
    • Polar graphs
      • Polar data and grid geometry
        • Source representation and conversion
        • Complex-vector ownership
        • Polar grid construction
        • Smith grid construction
        • Integration boundaries
        • Parallel parameter ownership and validation
        • Current counts versus cached sample storage
        • Complex mode selection and cleanup
        • Segment cache construction and failure policy
        • Label placement in full and cropped views
        • Formatter callbacks and cancellation
        • Geometry parameter domains and output storage
        • Formatter storage and cancellation
      • Polar data and geometry C reference
        • Element data adapters (rbcGrLine.c)
        • Grid geometry (rbcGrPolar.c)
        • Line and polar data transactions (rbcGrLine.c)
        • Label placement and presentation (rbcGrPolar.c)
        • Data records and member contracts
    • Tracks
      • Track ownership and layout
        • Records and dependencies
        • Configuration and axis ownership
        • Sizing and visible bounds
        • Local components and dispatch
        • Deletion and teardown
        • Maintenance checks
        • Axis-chain synchronization and option queries
        • Sash geometry and scroll fractions
        • Notification lifetime boundary
        • Dispatch and notification contracts
      • Track ownership C reference
        • Widget integration
        • Data records and member contracts
    • Markers
      • Marker lifecycle and drawing
        • Coordinates and mapping
        • Layers, order and visibility
        • Window markers
        • XOR paths
        • Export and cleanup
        • Common configuration and ownership
        • Coordinate and color parsing
        • Creation, replacement and rename
        • Bindings, point picking and region searches
        • Display-order changes
        • Teardown and invalidation details
        • Geometric markers: line, polygon and arc
          • Line shafts and arrowheads
          • Polygon fill versus outline
          • Arc mapping and output
          • Picking differences
          • Configuration and XOR lifetime
        • Bitmap, image, text and window resources
          • Bitmap masks and aliasing
          • Photo and non-photo image paths
          • Text layout and coordinate spaces
          • Child-window transitions and notifications
        • Pass dispatch and batching
          • Windows native batches
          • Cairo context reuse and native targets
          • Track and export paths
          • Windows scratch ownership
          • Geometry and batch argument contracts
      • Marker C reference
        • Mapping and output
        • Resource and record cleanup
        • Internal class interface
        • Shared implementation reference
          • Option preparation and commit
          • Record lifetime
          • Mapping helpers and picking
          • Registry and commands
        • Line geometry and lifetime
        • Polygon and arc geometry and ownership
        • Geometric renderer dispatch
        • Bitmap marker resources and presentation
        • Image marker resources and presentation
        • Text marker layout and presentation
        • Window marker geometry management and callbacks
        • Pass batching and renderer dispatch
        • Data records and member contracts
        • Implementation selectors
    • Legends
      • Legend ownership and layout
        • Entries and geometry
        • Drawing and picking
        • External window and redraw
        • Resource teardown
        • Record and construction boundaries
        • Configuration transaction
        • Detailed layout rules
        • Picking, tags and activation
        • Screen composition and export
        • External windows and command routing
        • Parameter and ownership boundaries
      • Legend C reference
        • Creation and configuration
        • Measurement and placement
        • Picking and binding identity
        • Screen and document output
        • Windows, scheduling and cleanup
        • Command handlers
    • Grids
      • Grid mapping and inheritance
        • Configuration and axis selection
        • Inherited and local state
        • Segment mapping
        • Screen and document output
        • Cleanup and regression checks
        • Tick transactions and duplicate options
        • Command transactions and visibility
        • Parameter boundaries for configuration and drawing
      • Grid C reference
        • Grid configuration and mapped caches
        • Mapping and output
        • Ownership and cleanup
        • Implementation helpers
        • Data records and member contracts
    • Crosshairs
      • Crosshair state and presentation
        • Requested and actual visibility
        • Motion and geometry changes
        • Double-buffered presentation
        • Direct drawing and teardown
        • Parsing and configuration boundaries
        • Command dispatch and idempotence
        • Parameter boundaries and lifecycle
      • Crosshair C reference
        • Lifecycle and background changes
        • Direct overlay control
        • Buffered presentation
        • Implementation helpers
        • Windows position-only transition
        • Data records and member contracts
    • Scrolling
      • Scrolling and viewport policy
        • Two parsing interfaces
        • Integer viewport modes
        • Axis data scrolling
        • Track stack versus track-local data
        • Scrollbar callbacks and lifetime
        • Integer conversion boundary
        • Argument slices and coordinate units
      • Scrolling C reference
        • Implementation helpers
  • Rendering and document export
    • Rendering architecture and contracts
      • Module boundaries
      • Contexts and capabilities
      • Clipping and coordinate rules
      • Native details and fallback policy
      • Common dispatch and constructor state
        • Screen fallback order
        • Validation at dispatch boundaries
      • Document ownership
      • Validation
      • Argument lifetimes and dispatch requirements
      • Screen text and raster batches
      • Export scopes and completion
      • Internal adapter contracts
    • Renderer C reference
      • Component-facing interface
      • Auxiliary types
      • Backend dispatch
      • Common screen adapters
    • Export orchestration and document ownership
      • Document state
      • SVG/PDF command transaction
      • Format policies and extension constraints
      • Graph traversal and geometry
      • PostScript policy and delivery
      • Parameter slices and failure boundaries
    • Export orchestration C reference
      • Document context
      • Graph command and traversal
      • SVG and PDF command helpers and format adapters
      • Data records and member contracts
      • Implementation selectors
    • Document renderer primitives
      • Context lifetime and state
      • Geometry and painter order
      • Fills, patterns and resource ownership
      • Images and masks
      • Text, borders and symbols
      • Errors and callback boundaries
      • Backend parameter and scope contracts
      • Shared backend setup
    • Document renderer C reference
      • Shared export support
      • PDF drawing callbacks
      • PostScript drawing callbacks
      • Context storage
    • Native renderers
      • Native renderer internals
        • Component-facing screen operations
        • Platform responsibilities
        • Backend contract navigation
        • Batch lifetime and coordinate conversion
        • Polygon and symbol batches
        • Rectangular clip frames
        • Windows DC clips
        • Runs and fallback boundaries
        • Shared primitive contracts
        • Arc strokes and arrowheads
        • X11 request and fallback contracts
        • Windows batch eligibility and ownership
        • Failure and cleanup boundaries
        • Windows compatibility resource boundary
        • Monochrome readback and fast paths
        • Windows compatibility primitives
          • Rectangles and arcs
          • XOR composition and direct fallback
          • Points and text
        • Windows bitmap capture and transforms
        • Internal template and buffer contracts
          • Bitmap packing and output ownership
        • Retained native geometry contexts
      • Shared and X11 native backend C reference
        • Trace batches
        • Clip stacks
        • Shared drawing implementation
        • X11 platform implementation
      • Windows native backend C reference
        • Tk Windows resource boundary
        • Compatibility drawing primitives
        • Bitmap capture and transforms
        • Native window handle lookup
        • DC and handle ownership
        • Tiled shapes
        • Windows header records
        • Platform-specific record extensions
    • Cairo renderer
      • Cairo surfaces and drawing contexts
        • Component-facing attempts
        • Construction and ownership
        • Path and resource contracts
        • Paths and clip scopes
        • Patterns and pixel conversion
        • Windows marker-pass target
        • Fallback and validation boundaries
        • Path consumption and batching
        • Coordinate and pattern state
      • Cairo backend C reference
        • Context storage
        • Windows context and marker-pass target
    • SVG exporter
      • SVG definitions and image encoding
        • Document and context lifetime
        • Definitions and scopes
        • Primitive geometry and paint
        • Symbol definitions and placement
        • Strings and error propagation
        • Raster encoding
        • Text and integration boundaries
        • Text placement and font finalization
        • Font-finalization failure boundary
      • SVG backend C reference
        • Context storage
    • PDF exporter
      • PDF resource builder and serialization
        • One export, one builder
        • Object numbers and resource categories
        • Reserved resources and streams
        • Serialization and errors
        • Cleanup boundaries
        • Stored geometry queries
      • PDF builder C reference
        • Data records and member contracts
    • PostScript exporter
      • PostScript output and drawing state
        • Token ownership
        • Prolog and page setup
        • Graphics-state boundaries
        • Legacy primitive contracts
        • Relief rectangles
        • Text and fill limitations
        • Raster ownership and encoding
        • Bitmap acquisition and payloads
        • Legacy font selection
        • Text transforms and fragment widths
        • Graph options and export lifetime
        • Page layout and preview paths
        • Delivery and ownership
        • Maintenance checks
        • Parameter and return-value boundaries
        • Command arguments and transaction boundaries
        • Variable-trace cancellation
      • PostScript token C reference
        • Persistent graph PostScript configuration
        • Token allocation and borrowed buffers
        • Appending syntax and loading prologs
        • Legacy drawing primitives
        • Raster payloads and capture
        • Font mapping and text placement
        • Graph options and document assembly
        • Windows binary preview packaging
        • Data records and member contracts
        • Implementation selectors
  • Images, fonts and windows
    • Image storage and tile clients
      • Pixel storage and Tk images
      • Allocation and photo-block conversion
      • Snapshot pipeline
      • Shared tile servers, individual clients
      • Idle refresh and notification
      • Origin and renderer boundaries
      • Cleanup and regression coverage
      • Registry and refresh implementation
      • Native shape drawing
    • Image and tile C reference
      • Tile queries and origins
      • Tile lifecycle implementation
      • Native tiled shapes
      • Storage and coordinate implementation
      • Drawable snapshot to photo
    • Image resizing and resampling
      • Three coordinate contracts
      • Filters and sampling weights
      • Kernel table and support
      • Contribution layout and rounding
      • Alpha and color space
      • Dimensions and failure policy
      • Photo wrappers and command policy
      • Nearest-neighbour implementation
      • Maintenance checks
    • Image resampling C reference
      • Filter kernels and contribution records
      • Contribution workspace records
    • Color-image rotation and bitmap transforms
      • Color-image rotation
      • Quadrant selection and intermediate geometry
      • Shear traversal and boundary pixels
      • One-bit bitmap ownership
      • Scaling and virtual regions
      • Failure and platform differences
      • Maintenance checks
      • X11 capture dimensions and visual channels
      • X11 capture and opacity-mask inputs
    • Image transform C reference
      • Color rotation implementation
      • X11 image and bitmap helpers
      • Data records and member contracts
    • Image color processing
      • Mutation and alpha
      • Greyscale and gamma
      • Square-kernel filtering
      • Palette reduction
      • Palette lookup coordinates
      • Quantizer stage contracts
      • Maintenance checks
    • Image color processing C reference
      • Palette-reduction implementation
      • Data records and member contracts
      • Implementation selectors
    • Temporary images and private Tk adapters
      • Private-layout access
      • Tk compatibility boundary
      • Two resources in a temporary photo
      • Deletion and failure ownership
      • Callbacks and interpreter state
      • Private cleanup tests
      • Maintenance checks
      • Image region and notification arguments
    • Image compatibility C reference
      • Data records and member contracts
    • Text layout and document fonts
      • Layouts borrow the text
      • Styles are not universal owners
      • Native layout presentation
      • Bitmap GC lifetime
      • Document-local font resolution
      • Native sources and font programs
      • Backend integration and cleanup
      • Reader trust boundaries
      • Unicode and legacy Symbol lookup
      • Name-keyed CFF metadata
      • SVG cmap reconstruction
      • PDF character codes and finalization
      • Parameter units and identifier domains
      • Choosing a text helper
    • Text and font C reference
      • Layout measurement
      • Style initialization and GC ownership
      • Document font cache
      • Shared text drawing implementation
      • Native font acquisition and parsing
      • PDF font resource encoding
      • Data records and member contracts
    • Shared drawing and window services
      • Graphics-context ownership
      • Request sizing and relief
      • Native identifiers
      • Window instance associations
      • Identifier and table lifetime details
      • Maintenance checks
      • Resource and stroke argument boundaries
      • Dash storage boundary
    • Shared drawing and window C reference
      • Window lookup and table cleanup internals
      • Native stroke setup
      • Dash descriptor scanning
    • Window and photo command implementation
      • Dispatch and platform boundaries
      • Native command contracts
      • Photo-operation ownership
      • Failure and callback boundaries
      • Maintenance checks
      • Command registration
    • Window/photo command C reference
      • Data records and member contracts
    • EPS canvas item implementation
      • Parsing and retained content
      • Preview ownership and configuration
      • Coordinates and export
      • Maintenance checks
      • Preview-byte decoding details
      • Small callback and geometry contracts
      • Canvas callback argument contracts
    • EPS canvas C reference
      • Data records and member contracts
  • Shared infrastructure
    • Component configuration and resources
      • Default values in option tables
      • Resource identity
      • Shared value parsers
      • Transactions
      • Lookup and configure metadata
      • Cleanup boundaries
      • Root and nested child lookup
      • Reading an option table
    • Component configuration C reference
      • Resource initialization
      • Rollback
      • Option lookup and metadata
      • Relative child lookup
      • Data records and member contracts
      • Component option tables
    • Binding dispatch and picking
      • Responsibilities
      • Objects, contexts and binding keys
      • Graph hit priority
      • Legend picking and occlusion
      • Pointer transitions and button state
      • Dispatch and configuration
      • Lifetime and deletion
      • Validation when changing behavior
    • Binding and picking C reference
      • Binding table state
      • Shared interface
      • Internal dispatch callbacks
      • Graph-specific callbacks
    • Geometry, clipping and simplification
      • Coordinates and borrowed storage
      • Hit testing
      • Line and polygon clipping differ
      • Simplification and original indices
      • Private validation and subdivision
      • Output capacity and completion contracts
    • Geometry C reference
      • Implementation helpers
      • Data records and member contracts
    • Chains and keyed lists
      • Choosing and owning a container
      • Keys and node creation
      • Linking and moving
      • Borrowed pointers and traversal
      • Sorting and positional lookup
      • Insertion and lookup contracts
      • Private key lookup contracts
      • Parameter contracts and construction states
    • Container C reference
      • Implementation helpers
      • Creation, insertion and lookup
      • Data records and member contracts
    • Allocation, strings and interned names
      • Allocation and failure policy
      • UID table
      • Formatting and result assembly
      • Other utility boundaries
      • Maintenance checks
      • Dictionary ordering and fatal diagnostics
      • Byte-string case conversion
      • Fallback byte-string comparisons
    • Utility ownership C reference
      • Ordering, stdio and fatal diagnostics
    • Typed command dispatch
      • Table layout and lifetime
      • Argument counts and diagnostics
      • Selection versus execution
      • Maintenance checks
      • Lookup inputs and output
      • Operation families and their record types
    • Typed dispatch C reference
      • Implementation selectors
    • Shared value conversion and numeric policy
      • Screen units and staged values
      • Dashes and callbacks
      • Strings and matching policies
      • Numeric compatibility macros
      • Maintenance checks
      • Legacy color-pair adapter
      • Legacy adapter replacement and printing
      • Output parameters are not interchangeable
    • Value conversion C reference
      • Private parsing and legacy Tk adapters
    • Numeric compatibility C reference
RBC Developer Manual
  • Search


© Copyright .

Built with Sphinx using a theme provided by Read the Docs.