@ringozz/godot 0.1.0

package/gen/classes/FoldableContainer.ts

@@ -0,0 +1,110 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Container } from './Container.ts';
+import type { HorizontalAlignment } from '../global-enums.ts';
+import type { Signal } from '../heap-types/index.ts';
+import type { Control, TextDirection } from './Control.ts';
+import type { FoldableGroup } from './FoldableGroup.ts';
+import type { OverrunBehavior } from './TextServer.ts';
+
+/**
+ * A container that can be expanded/collapsed, with a title that can be filled with controls, such as buttons. This is also called an accordion.
+ * The title can be positioned at the top or bottom of the container. The container can be expanded or collapsed by clicking the title or by pressing `ui_accept` when focused. Child control nodes are hidden when the container is collapsed. Ignores non-control children.
+ * A FoldableContainer can be grouped with other FoldableContainers so that only one of them can be opened at a time; see {@link foldableGroup} and {@link FoldableGroup}.
+ */
+export class FoldableContainer extends Container {
+    constructor(name = 270) { super(name); }
+
+    /**
+     * Folds the container and emits {@link folding_changed}.
+     */
+    fold(): void { _C(this, 3375); }
+
+    /**
+     * Expands the container and emits {@link folding_changed}.
+     */
+    expand(): void { _C(this, 3187); }
+
+    /**
+     * Adds a {@link Control} that will be placed next to the container's title, obscuring the clickable area. Prime usage is adding {@link Button} nodes, but it can be any {@link Control}.
+     * The control will be added as a child of this container and removed from previous parent if necessary. The controls will be placed aligned to the right, with the first added control being the leftmost one.
+     */
+    addTitleBarControl(control: Control): void { _C(this, 1314, control); }
+
+    /**
+     * Removes a {@link Control} added with {@link addTitleBarControl}. The node is not freed automatically, you need to use {@link Node.queueFree}.
+     */
+    removeTitleBarControl(control: Control): void { _C(this, 9977, control); }
+
+    /**
+     * If `true`, the container will become folded and will hide all its children.
+     */
+    get folded(): boolean { return _C(this, 7963) as boolean; }
+    set folded(v: boolean) { _C(this, 11446, v); }
+
+    /**
+     * The container's title text.
+     */
+    get title(): string { return _C(this, 6829) as string; }
+    set title(v: string) { _C(this, 13099, v); }
+
+    /**
+     * Title's horizontal text alignment.
+     */
+    get titleAlignment(): HorizontalAlignment { return _C(this, 6830) as HorizontalAlignment; }
+    set titleAlignment(v: HorizontalAlignment) { _C(this, 13100, v); }
+
+    /**
+     * Title's position.
+     */
+    get titlePosition(): TitlePosition { return _C(this, 6831) as TitlePosition; }
+    set titlePosition(v: TitlePosition) { _C(this, 13101, v); }
+
+    /**
+     * Defines the behavior of the title when the text is longer than the available space.
+     */
+    get titleTextOverrunBehavior(): OverrunBehavior { return _C(this, 6833) as OverrunBehavior; }
+    set titleTextOverrunBehavior(v: OverrunBehavior) { _C(this, 13103, v); }
+
+    /**
+     * The {@link FoldableGroup} associated with the container. When multiple {@link FoldableContainer} nodes share the same group, only one of them is allowed to be unfolded.
+     */
+    get foldableGroup(): FoldableGroup { return _C(this, 4841) as FoldableGroup; }
+    set foldableGroup(v: FoldableGroup) { _C(this, 11445, v); }
+
+    /**
+     * Title text writing direction.
+     */
+    get titleTextDirection(): TextDirection { return _C(this, 6832) as TextDirection; }
+    set titleTextDirection(v: TextDirection) { _C(this, 13102, v); }
+
+    /**
+     * Language code used for text shaping algorithms. If left empty, the current locale is used instead.
+     */
+    get language(): string { return _C(this, 5299) as string; }
+    set language(v: string) { _C(this, 11871, v); }
+
+    /**
+     * Emitted when the container is folded/expanded.
+     */
+    get foldingChanged(): Signal<(isFolded: boolean) => void> { return _G(this, 3381) as Signal<(isFolded: boolean) => void>; }
+    set foldingChanged(v: ((isFolded: boolean) => void) | null) { _G(this, 3381, v); }
+
+    static readonly name = _R(270, FoldableContainer);
+}
+
+export const TitlePosition = {
+    /**
+     * Makes the title appear at the top of the container.
+     */
+    POSITION_TOP: 0,
+    /**
+     * Makes the title appear at the bottom of the container. Also makes all StyleBoxes flipped vertically.
+     */
+    POSITION_BOTTOM: 1,
+} as const;
+
+export type TitlePosition = (typeof TitlePosition)[keyof typeof TitlePosition];
+

package/gen/classes/FoldableGroup.ts

@@ -0,0 +1,38 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { GodotArray, Signal } from '../heap-types/index.ts';
+import type { FoldableContainer } from './FoldableContainer.ts';
+
+/**
+ * A group of {@link FoldableContainer}-derived nodes. Only one container can be expanded at a time.
+ */
+export class FoldableGroup extends Resource {
+    constructor(name = 271) { super(name); }
+
+    /**
+     * Returns the current expanded container.
+     */
+    getExpandedContainer(): FoldableContainer { return _C(this, 4707) as FoldableContainer; }
+
+    /**
+     * Returns an {@link Array} of {@link FoldableContainer}s that have this as their FoldableGroup (see {@link FoldableContainer.foldableGroup}). This is equivalent to {@link ButtonGroup} but for FoldableContainers.
+     */
+    getContainers(): GodotArray<FoldableContainer> { return _C(this, 4309) as GodotArray<FoldableContainer>; }
+
+    /**
+     * If `true`, it is possible to fold all containers in this FoldableGroup.
+     */
+    get allowFoldingAll(): boolean { return _C(this, 7752) as boolean; }
+    set allowFoldingAll(v: boolean) { _C(this, 10452, v); }
+
+    /**
+     * Emitted when one of the containers of the group is expanded.
+     */
+    get expanded(): Signal<(container: FoldableContainer) => void> { return _G(this, 3195) as Signal<(container: FoldableContainer) => void>; }
+    set expanded(v: ((container: FoldableContainer) => void) | null) { _G(this, 3195, v); }
+
+    static readonly name = _R(271, FoldableGroup);
+}

package/gen/classes/Font.ts

@@ -0,0 +1,242 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { HorizontalAlignment, Orientation } from '../global-enums.ts';
+import type { GodotArray, GodotDictionary, PackedColorArray, RID } from '../heap-types/index.ts';
+import type { Color, Transform2D, Vector2 } from '../value-types/index.ts';
+import type { Direction, FontStyle, JustificationFlag, LineBreakFlag, SpacingType } from './TextServer.ts';
+
+/**
+ * Abstract base class for different font types. It has methods for drawing text and font character introspection.
+ */
+export class Font extends Resource {
+
+    /**
+     * Returns {@link TextServer} RID of the font cache for specific variation.
+     */
+    findVariation(variationCoordinates: GodotDictionary, faceIndex?: number /* = 0 */, strength?: number /* = 0.0 */, transform?: Transform2D /* = Transform2D(1, 0, 0, 1, 0, 0) */, spacingTop?: number /* = 0 */, spacingBottom?: number /* = 0 */, spacingSpace?: number /* = 0 */, spacingGlyph?: number /* = 0 */, baselineOffset?: number /* = 0.0 */, paletteIndex?: number /* = 0,  int64 */, customColors?: PackedColorArray /* = PackedColorArray() */): RID { return _C(this, 3305, variationCoordinates, faceIndex, strength, transform, spacingTop, spacingBottom, spacingSpace, spacingGlyph, baselineOffset, paletteIndex, customColors) as RID; }
+
+    /**
+     * Returns {@link Array} of valid {@link Font} {@link RID}s, which can be passed to the {@link TextServer} methods.
+     */
+    getRids(): GodotArray<RID> { return _C(this, 6178) as GodotArray<RID>; }
+
+    /**
+     * Returns the total average font height (ascent plus descent) in pixels.
+     * **Note:** Real height of the string is context-dependent and can be significantly different from the value returned by this function. Use it only as rough estimate (e.g. as the height of empty line).
+     */
+    getHeight(fontSize?: number /* = 16 */): number { return _C(this, 5024, fontSize) as number; }
+
+    /**
+     * Returns the maximum font ascent (number of pixels above the baseline) of this font and all fallback fonts.
+     * **Note:** Real ascent of the string is context-dependent and can be significantly different from the value returned by this function. Use it only as rough estimate (e.g. as the ascent of empty line).
+     */
+    getAscent(fontSize?: number /* = 16 */): number { return _C(this, 3799, fontSize) as number; }
+
+    /**
+     * Returns the maximum font descent (number of pixels below the baseline) of this font and all fallback fonts.
+     * **Note:** Real descent of the string is context-dependent and can be significantly different from the value returned by this function. Use it only as rough estimate (e.g. as the descent of empty line).
+     */
+    getDescent(fontSize?: number /* = 16 */): number { return _C(this, 4483, fontSize) as number; }
+
+    /**
+     * Returns average pixel offset of the underline below the baseline.
+     * **Note:** Real underline position of the string is context-dependent and can be significantly different from the value returned by this function. Use it only as rough estimate.
+     */
+    getUnderlinePosition(fontSize?: number /* = 16 */): number { return _C(this, 6945, fontSize) as number; }
+
+    /**
+     * Returns average thickness of the underline.
+     * **Note:** Real underline thickness of the string is context-dependent and can be significantly different from the value returned by this function. Use it only as rough estimate.
+     */
+    getUnderlineThickness(fontSize?: number /* = 16 */): number { return _C(this, 6946, fontSize) as number; }
+
+    /**
+     * Returns font family name.
+     */
+    getFontName(): string { return _C(this, 4850) as string; }
+
+    /**
+     * Returns font style name.
+     */
+    getFontStyleName(): string { return _C(this, 4857) as string; }
+
+    /**
+     * Returns {@link Dictionary} with OpenType font name strings (localized font names, version, description, license information, sample text, etc.).
+     */
+    getOtNameStrings(): GodotDictionary { return _C(this, 5751) as GodotDictionary; }
+
+    /**
+     * Returns font style flags.
+     */
+    getFontStyle(): FontStyle { return _C(this, 4856) as FontStyle; }
+
+    /**
+     * Returns weight (boldness) of the font. A value in the `100...999` range, normal font weight is `400`, bold font weight is `700`.
+     */
+    getFontWeight(): number { return _C(this, 4859) as number; }
+
+    /**
+     * Returns font stretch amount, compared to a normal width. A percentage value between `50%` and `200%`.
+     */
+    getFontStretch(): number { return _C(this, 4855) as number; }
+
+    /**
+     * Returns the number of predefined color palettes. Palette contains all colors used to render font glyphs. Each palette has the same number of colors.
+     */
+    getPaletteCount(): number { return _C(this, 5796) as number; }
+
+    /**
+     * Returns the name of the predefined color palette at `index`. Palette contains all colors used to render font glyphs. Each palette has the same number of colors.
+     */
+    getPaletteName(index: number /* int64 */): string { return _C(this, 5799, index) as string; }
+
+    /**
+     * Returns the array in the predefined color palette at `index`. Palette contains all colors used to render font glyphs. Each palette has the same number of colors. Colors can be overridden using {@link FontVariation}.
+     */
+    getPaletteColors(index: number /* int64 */): PackedColorArray { return _C(this, 5795, index) as PackedColorArray; }
+
+    /**
+     * Returns the amount of spacing for the given `spacing` type.
+     */
+    getSpacing(spacing: SpacingType): number { return _C(this, 6466, spacing) as number; }
+
+    /**
+     * Returns a set of OpenType feature tags. More info: [OpenType feature tags](https://docs.microsoft.com/en-us/typography/opentype/spec/featuretags).
+     */
+    getOpentypeFeatures(): GodotDictionary { return _C(this, 5724) as GodotDictionary; }
+
+    /**
+     * Sets LRU cache capacity for `draw_*` methods.
+     */
+    setCacheCapacity(singleLine: number, multiLine: number): void { _C(this, 10774, singleLine, multiLine); }
+
+    /**
+     * Returns the size of a bounding box of a single-line string, taking kerning, advance and subpixel positioning into account. See also {@link getMultilineStringSize} and {@link drawString}.
+     * For example, to get the string size as displayed by a single-line Label, use:
+     *
+     *
+     * ```gdscript
+     *
+     * var string_size = $Label.get_theme_font("font").get_string_size($Label.text, HORIZONTAL_ALIGNMENT_LEFT, -1, $Label.get_theme_font_size("font_size"))
+     *
+     * ```
+     *
+     *
+     *
+     * **Note:** Since kerning, advance and subpixel positioning are taken into account by {@link getStringSize}, using separate {@link getStringSize} calls on substrings of a string then adding the results together will return a different result compared to using a single {@link getStringSize} call on the full string.
+     * **Note:** Real height of the string is context-dependent and can be significantly different from the value returned by {@link getHeight}.
+     */
+    getStringSize(text: string, alignment?: HorizontalAlignment /* = 0 */, width?: number /* = -1 */, fontSize?: number /* = 16 */, justificationFlags?: JustificationFlag /* = 3 */, direction?: Direction /* = 0 */, orientation?: Orientation /* = 0 */): Vector2 { return _C(this, 6582, text, alignment, width, fontSize, justificationFlags, direction, orientation) as Vector2; }
+
+    /**
+     * Returns the size of a bounding box of a string broken into the lines, taking kerning and advance into account.
+     * See also {@link drawMultilineString}.
+     */
+    getMultilineStringSize(text: string, alignment?: HorizontalAlignment /* = 0 */, width?: number /* = -1 */, fontSize?: number /* = 16 */, maxLines?: number /* = -1 */, brkFlags?: LineBreakFlag /* = 3 */, justificationFlags?: JustificationFlag /* = 3 */, direction?: Direction /* = 0 */, orientation?: Orientation /* = 0 */): Vector2 { return _C(this, 5597, text, alignment, width, fontSize, maxLines, brkFlags, justificationFlags, direction, orientation) as Vector2; }
+
+    /**
+     * Draw `text` into a canvas item using the font, at a given position, with `modulate` color, optionally clipping the width and aligning horizontally. `pos` specifies the baseline, not the top. To draw from the top, *ascent* must be added to the Y axis. If `oversampling` is greater than zero, it is used as font oversampling factor, otherwise viewport oversampling settings are used.
+     * See also {@link CanvasItem.drawString}.
+     */
+    drawString(canvasItem: RID, pos: Vector2, text: string, alignment?: HorizontalAlignment /* = 0 */, width?: number /* = -1 */, fontSize?: number /* = 16 */, modulate?: Color /* = Color(1, 1, 1, 1) */, justificationFlags?: JustificationFlag /* = 3 */, direction?: Direction /* = 0 */, orientation?: Orientation /* = 0 */, oversampling?: number /* = 0.0 */): void { _C(this, 2966, canvasItem, pos, text, alignment, width, fontSize, modulate, justificationFlags, direction, orientation, oversampling); }
+
+    /**
+     * Breaks `text` into lines using rules specified by `brkFlags` and draws it into a canvas item using the font, at a given position, with `modulate` color, optionally clipping the width and aligning horizontally. `pos` specifies the baseline of the first line, not the top. To draw from the top, *ascent* must be added to the Y axis. If `oversampling` is greater than zero, it is used as font oversampling factor, otherwise viewport oversampling settings are used.
+     * See also {@link CanvasItem.drawMultilineString}.
+     */
+    drawMultilineString(canvasItem: RID, pos: Vector2, text: string, alignment?: HorizontalAlignment /* = 0 */, width?: number /* = -1 */, fontSize?: number /* = 16 */, maxLines?: number /* = -1 */, modulate?: Color /* = Color(1, 1, 1, 1) */, brkFlags?: LineBreakFlag /* = 3 */, justificationFlags?: JustificationFlag /* = 3 */, direction?: Direction /* = 0 */, orientation?: Orientation /* = 0 */, oversampling?: number /* = 0.0 */): void { _C(this, 2946, canvasItem, pos, text, alignment, width, fontSize, maxLines, modulate, brkFlags, justificationFlags, direction, orientation, oversampling); }
+
+    /**
+     * Draw `text` outline into a canvas item using the font, at a given position, with `modulate` color and `size` outline size, optionally clipping the width and aligning horizontally. `pos` specifies the baseline, not the top. To draw from the top, *ascent* must be added to the Y axis. If `oversampling` is greater than zero, it is used as font oversampling factor, otherwise viewport oversampling settings are used.
+     * See also {@link CanvasItem.drawStringOutline}.
+     */
+    drawStringOutline(canvasItem: RID, pos: Vector2, text: string, alignment?: HorizontalAlignment /* = 0 */, width?: number /* = -1 */, fontSize?: number /* = 16 */, size?: number /* = 1 */, modulate?: Color /* = Color(1, 1, 1, 1) */, justificationFlags?: JustificationFlag /* = 3 */, direction?: Direction /* = 0 */, orientation?: Orientation /* = 0 */, oversampling?: number /* = 0.0 */): void { _C(this, 2967, canvasItem, pos, text, alignment, width, fontSize, size, modulate, justificationFlags, direction, orientation, oversampling); }
+
+    /**
+     * Breaks `text` to the lines using rules specified by `brkFlags` and draws text outline into a canvas item using the font, at a given position, with `modulate` color and `size` outline size, optionally clipping the width and aligning horizontally. `pos` specifies the baseline of the first line, not the top. To draw from the top, *ascent* must be added to the Y axis. If `oversampling` is greater than zero, it is used as font oversampling factor, otherwise viewport oversampling settings are used.
+     * See also {@link CanvasItem.drawMultilineStringOutline}.
+     */
+    drawMultilineStringOutline(canvasItem: RID, pos: Vector2, text: string, alignment?: HorizontalAlignment /* = 0 */, width?: number /* = -1 */, fontSize?: number /* = 16 */, maxLines?: number /* = -1 */, size?: number /* = 1 */, modulate?: Color /* = Color(1, 1, 1, 1) */, brkFlags?: LineBreakFlag /* = 3 */, justificationFlags?: JustificationFlag /* = 3 */, direction?: Direction /* = 0 */, orientation?: Orientation /* = 0 */, oversampling?: number /* = 0.0 */): void { _C(this, 2947, canvasItem, pos, text, alignment, width, fontSize, maxLines, size, modulate, brkFlags, justificationFlags, direction, orientation, oversampling); }
+
+    /**
+     * Returns the size of a character. Does not take kerning into account.
+     * **Note:** Do not use this function to calculate width of the string character by character, use {@link getStringSize} or {@link TextLine} instead. The height returned is the font height (see also {@link getHeight}) and has no relation to the glyph height.
+     */
+    getCharSize(_char: number /* char32 */, fontSize: number): Vector2 { return _C(this, 4142, _char, fontSize) as Vector2; }
+
+    /**
+     * Draw a single Unicode character `char` into a canvas item using the font, at a given position, with `modulate` color. `pos` specifies the baseline, not the top. To draw from the top, *ascent* must be added to the Y axis. If `oversampling` is greater than zero, it is used as font oversampling factor, otherwise viewport oversampling settings are used.
+     * **Note:** Do not use this function to draw strings character by character, use {@link drawString} or {@link TextLine} instead.
+     */
+    drawChar(canvasItem: RID, pos: Vector2, _char: number /* char32 */, fontSize: number, modulate?: Color /* = Color(1, 1, 1, 1) */, oversampling?: number /* = 0.0 */): number { return _C(this, 2906, canvasItem, pos, _char, fontSize, modulate, oversampling) as number; }
+
+    /**
+     * Draw a single Unicode character `char` outline into a canvas item using the font, at a given position, with `modulate` color and `size` outline size. `pos` specifies the baseline, not the top. To draw from the top, *ascent* must be added to the Y axis. If `oversampling` is greater than zero, it is used as font oversampling factor, otherwise viewport oversampling settings are used.
+     * **Note:** Do not use this function to draw strings character by character, use {@link drawString} or {@link TextLine} instead.
+     */
+    drawCharOutline(canvasItem: RID, pos: Vector2, _char: number /* char32 */, fontSize: number, size?: number /* = -1 */, modulate?: Color /* = Color(1, 1, 1, 1) */, oversampling?: number /* = 0.0 */): number { return _C(this, 2907, canvasItem, pos, _char, fontSize, size, modulate, oversampling) as number; }
+
+    /**
+     * Returns `true` if a Unicode `char` is available in the font.
+     */
+    hasChar(_char: number /* char32 */): boolean { return _C(this, 7375, _char) as boolean; }
+
+    /**
+     * Returns a string containing all the characters available in the font.
+     * If a given character is included in more than one font data source, it appears only once in the returned string.
+     */
+    getSupportedChars(): string { return _C(this, 6616) as string; }
+
+    /**
+     * Returns `true` if the font supports the given language (as a [ISO 639](https://en.wikipedia.org/wiki/ISO_639-1) code).
+     */
+    isLanguageSupported(language: string): boolean { return _C(this, 8063, language) as boolean; }
+
+    /**
+     * Returns `true` if the font supports the given script (as a [ISO 15924](https://en.wikipedia.org/wiki/ISO_15924) code).
+     */
+    isScriptSupported(script: string): boolean { return _C(this, 8271, script) as boolean; }
+
+    /**
+     * Returns list of OpenType features supported by font.
+     */
+    getSupportedFeatureList(): GodotDictionary { return _C(this, 6618) as GodotDictionary; }
+
+    /**
+     * Returns list of supported [variation coordinates](https://docs.microsoft.com/en-us/typography/opentype/spec/dvaraxisreg), each coordinate is returned as `tag: Vector3i(min_value,max_value,default_value)`.
+     * Font variations allow for continuous change of glyph characteristics along some given design axis, such as weight, width or slant.
+     * To print available variation axes of a variable font:
+     *
+     * ```text
+     *
+     * var fv = FontVariation.new()
+     * fv.base_font = load("res://RobotoFlex.ttf")
+     * var variation_list = fv.get_supported_variation_list()
+     * for tag in variation_list:
+     * 	var name = TextServerManager.get_primary_interface().tag_to_name(tag)
+     * 	var values = variation_list[tag]
+     * 	print("variation axis: %s (%d)\n\tmin, max, default: %s" % [name, tag, values])
+     *
+     * ```
+     *
+     * **Note:** To set and get variation coordinates of a {@link FontVariation}, use {@link FontVariation.variationOpentype}.
+     */
+    getSupportedVariationList(): GodotDictionary { return _C(this, 6622) as GodotDictionary; }
+
+    /**
+     * Returns number of faces in the TrueType / OpenType collection.
+     */
+    getFaceCount(): number { return _C(this, 4729) as number; }
+
+    /**
+     * Array of fallback {@link Font}s to use as a substitute if a glyph is not found in this current {@link Font}.
+     * If this array is empty in a {@link FontVariation}, the {@link FontVariation.baseFont}'s fallbacks are used instead.
+     */
+    get fallbacks(): GodotArray<Font> { return _C(this, 4757) as GodotArray<Font>; }
+    set fallbacks(v: GodotArray<Font>) { _C(this, 11368, v); }
+
+    static readonly name = _R(272, Font);
+}