janishutz/dotfiles
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Activity

[Notes] Some changes

Browse Source
This commit is contained in:
Janis Hutz
2025-04-25 06:51:13 +02:00
parent 10136ab9de
commit b5ad7e3034
198 changed files with 1916125 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

573
config/ags/quickactions/@girs/gstcontroller-1.0.d.ts vendored Normal file
View File

@@ -0,0 +1,573 @@
/// <reference path="./gst-1.0.d.ts" />
/// <reference path="./gobject-2.0.d.ts" />
/// <reference path="./glib-2.0.d.ts" />
/// <reference path="./gmodule-2.0.d.ts" />
/**
* Type Definitions for Gjs (https://gjs.guide/)
*
* These type definitions are automatically generated, do not edit them by hand.
* If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
*
* The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
*/
declare module 'gi://GstController?version=1.0' {
// Module dependencies
import type Gst from 'gi://Gst?version=1.0';
import type GObject from 'gi://GObject?version=2.0';
import type GLib from 'gi://GLib?version=2.0';
import type GModule from 'gi://GModule?version=2.0';
export namespace GstController {
/**
* GstController-1.0
*/
/**
* The various interpolation modes available.
*/
/**
* The various interpolation modes available.
*/
export namespace InterpolationMode {
export const $gtype: GObject.GType<InterpolationMode>;
}
enum InterpolationMode {
/**
* steps-like interpolation, default
*/
NONE,
/**
* linear interpolation
*/
LINEAR,
/**
* cubic interpolation (natural), may overshoot
* the min or max values set by the control point, but is more 'curvy'
*/
CUBIC,
/**
* monotonic cubic interpolation, will not
* produce any values outside of the min-max range set by the control points
* (Since: 1.8)
*/
CUBIC_MONOTONIC,
}
/**
* The various waveform modes available.
*/
/**
* The various waveform modes available.
*/
export namespace LFOWaveform {
export const $gtype: GObject.GType<LFOWaveform>;
}
enum LFOWaveform {
/**
* sine waveform
*/
SINE,
/**
* square waveform
*/
SQUARE,
/**
* saw waveform
*/
SAW,
/**
* reverse saw waveform
*/
REVERSE_SAW,
/**
* triangle waveform
*/
TRIANGLE,
}
/**
* Reset the controlled value cache.
* @param self the #GstTimedValueControlSource
*/
function timed_value_control_invalidate_cache(self: TimedValueControlSource): void;
interface DirectControlBindingConvertGValue {
(self: DirectControlBinding, src_value: number, dest_value: GObject.Value | any): void;
}
interface DirectControlBindingConvertValue {
(self: DirectControlBinding, src_value: number, dest_value?: any | null): void;
}
namespace ARGBControlBinding {
// Constructor properties interface
interface ConstructorProps extends Gst.ControlBinding.ConstructorProps {
control_source_a: Gst.ControlSource;
controlSourceA: Gst.ControlSource;
control_source_b: Gst.ControlSource;
controlSourceB: Gst.ControlSource;
control_source_g: Gst.ControlSource;
controlSourceG: Gst.ControlSource;
control_source_r: Gst.ControlSource;
controlSourceR: Gst.ControlSource;
}
}
/**
* A value mapping object that attaches multiple control sources to a guint
* gobject properties representing a color. A control value of 0.0 will turn the
* color component off and a value of 1.0 will be the color level.
*/
class ARGBControlBinding extends Gst.ControlBinding {
static $gtype: GObject.GType<ARGBControlBinding>;
// Properties
get control_source_a(): Gst.ControlSource;
set control_source_a(val: Gst.ControlSource);
get controlSourceA(): Gst.ControlSource;
set controlSourceA(val: Gst.ControlSource);
get control_source_b(): Gst.ControlSource;
set control_source_b(val: Gst.ControlSource);
get controlSourceB(): Gst.ControlSource;
set controlSourceB(val: Gst.ControlSource);
get control_source_g(): Gst.ControlSource;
set control_source_g(val: Gst.ControlSource);
get controlSourceG(): Gst.ControlSource;
set controlSourceG(val: Gst.ControlSource);
get control_source_r(): Gst.ControlSource;
set control_source_r(val: Gst.ControlSource);
get controlSourceR(): Gst.ControlSource;
set controlSourceR(val: Gst.ControlSource);
// Constructors
constructor(properties?: Partial<ARGBControlBinding.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](
object: Gst.Object,
property_name: string,
cs_a: Gst.ControlSource,
cs_r: Gst.ControlSource,
cs_g: Gst.ControlSource,
cs_b: Gst.ControlSource,
): ARGBControlBinding;
}
namespace DirectControlBinding {
// Constructor properties interface
interface ConstructorProps extends Gst.ControlBinding.ConstructorProps {
absolute: boolean;
control_source: Gst.ControlSource;
controlSource: Gst.ControlSource;
}
}
/**
* A value mapping object that attaches control sources to gobject properties. It
* will map the control values directly to the target property range. If a
* non-absolute direct control binding is used, the value range [0.0 ... 1.0]
* is mapped to full target property range, and all values outside the range
* will be clipped. An absolute control binding will not do any value
* transformations.
*/
class DirectControlBinding extends Gst.ControlBinding {
static $gtype: GObject.GType<DirectControlBinding>;
// Properties
get absolute(): boolean;
get control_source(): Gst.ControlSource;
set control_source(val: Gst.ControlSource);
get controlSource(): Gst.ControlSource;
set controlSource(val: Gst.ControlSource);
// Constructors
constructor(properties?: Partial<DirectControlBinding.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](object: Gst.Object, property_name: string, cs: Gst.ControlSource): DirectControlBinding;
static new_absolute(object: Gst.Object, property_name: string, cs: Gst.ControlSource): DirectControlBinding;
}
namespace InterpolationControlSource {
// Constructor properties interface
interface ConstructorProps extends TimedValueControlSource.ConstructorProps {
mode: InterpolationMode;
}
}
/**
* #GstInterpolationControlSource is a #GstControlSource, that interpolates values between user-given
* control points. It supports several interpolation modes and property types.
*
* To use #GstInterpolationControlSource get a new instance by calling
* gst_interpolation_control_source_new(), bind it to a #GParamSpec and set some
* control points by calling gst_timed_value_control_source_set().
*
* All functions are MT-safe.
*/
class InterpolationControlSource extends TimedValueControlSource {
static $gtype: GObject.GType<InterpolationControlSource>;
// Properties
get mode(): InterpolationMode;
set mode(val: InterpolationMode);
// Constructors
constructor(properties?: Partial<InterpolationControlSource.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](): InterpolationControlSource;
}
namespace LFOControlSource {
// Constructor properties interface
interface ConstructorProps extends Gst.ControlSource.ConstructorProps {
amplitude: number;
frequency: number;
offset: number;
timeshift: number;
waveform: LFOWaveform;
}
}
/**
* #GstLFOControlSource is a #GstControlSource, that provides several periodic
* waveforms as control values.
*
* To use #GstLFOControlSource get a new instance by calling
* gst_lfo_control_source_new(), bind it to a #GParamSpec and set the relevant
* properties.
*
* All functions are MT-safe.
*/
class LFOControlSource extends Gst.ControlSource {
static $gtype: GObject.GType<LFOControlSource>;
// Properties
/**
* Specifies the amplitude for the waveform of this #GstLFOControlSource.
*/
get amplitude(): number;
set amplitude(val: number);
/**
* Specifies the frequency that should be used for the waveform
* of this #GstLFOControlSource. It should be large enough
* so that the period is longer than one nanosecond.
*/
get frequency(): number;
set frequency(val: number);
/**
* Specifies the value offset for the waveform of this #GstLFOControlSource.
*/
get offset(): number;
set offset(val: number);
/**
* Specifies the timeshift to the right that should be used for the waveform
* of this #GstLFOControlSource in nanoseconds.
*
* To get a n nanosecond shift to the left use
* "(GST_SECOND / frequency) - n".
*/
get timeshift(): number;
set timeshift(val: number);
/**
* Specifies the waveform that should be used for this #GstLFOControlSource.
*/
get waveform(): LFOWaveform;
set waveform(val: LFOWaveform);
// Constructors
constructor(properties?: Partial<LFOControlSource.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](): LFOControlSource;
}
namespace ProxyControlBinding {
// Constructor properties interface
interface ConstructorProps extends Gst.ControlBinding.ConstructorProps {}
}
/**
* A #GstControlBinding that forwards requests to another #GstControlBinding
*/
class ProxyControlBinding extends Gst.ControlBinding {
static $gtype: GObject.GType<ProxyControlBinding>;
// Constructors
constructor(properties?: Partial<ProxyControlBinding.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](
object: Gst.Object,
property_name: string,
ref_object: Gst.Object,
ref_property_name: string,
): ProxyControlBinding;
}
namespace TimedValueControlSource {
// Signal callback interfaces
interface ValueAdded {
(timed_value: ControlPoint): void;
}
interface ValueChanged {
(timed_value: ControlPoint): void;
}
interface ValueRemoved {
(timed_value: ControlPoint): void;
}
// Constructor properties interface
interface ConstructorProps extends Gst.ControlSource.ConstructorProps {}
}
/**
* Base class for #GstControlSource that use time-stamped values.
*
* When overriding bind, chain up first to give this bind implementation a
* chance to setup things.
*
* All functions are MT-safe.
*/
abstract class TimedValueControlSource extends Gst.ControlSource {
static $gtype: GObject.GType<TimedValueControlSource>;
// Fields
nvalues: number;
valid_cache: boolean;
// Constructors
constructor(properties?: Partial<TimedValueControlSource.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
// Signals
connect(id: string, callback: (...args: any[]) => any): number;
connect_after(id: string, callback: (...args: any[]) => any): number;
emit(id: string, ...args: any[]): void;
connect(signal: 'value-added', callback: (_source: this, timed_value: ControlPoint) => void): number;
connect_after(signal: 'value-added', callback: (_source: this, timed_value: ControlPoint) => void): number;
emit(signal: 'value-added', timed_value: ControlPoint): void;
connect(signal: 'value-changed', callback: (_source: this, timed_value: ControlPoint) => void): number;
connect_after(
signal: 'value-changed',
callback: (_source: this, timed_value: ControlPoint) => void,
): number;
emit(signal: 'value-changed', timed_value: ControlPoint): void;
connect(signal: 'value-removed', callback: (_source: this, timed_value: ControlPoint) => void): number;
connect_after(
signal: 'value-removed',
callback: (_source: this, timed_value: ControlPoint) => void,
): number;
emit(signal: 'value-removed', timed_value: ControlPoint): void;
// Methods
/**
* Find last value before given timestamp in control point list.
* If all values in the control point list come after the given
* timestamp or no values exist, %NULL is returned.
*
* For use in control source implementations.
* @param timestamp the search key
* @returns the found #GSequenceIter or %NULL
*/
find_control_point_iter(timestamp: Gst.ClockTime): GLib.SequenceIter | null;
/**
* Returns a read-only copy of the list of #GstTimedValue for the given property.
* Free the list after done with it.
* @returns a copy of the list, or %NULL if the property isn't handled by the controller
*/
get_all(): Gst.TimedValue[];
/**
* Get the number of control points that are set.
* @returns the number of control points that are set.
*/
get_count(): number;
/**
* Set the value of given controller-handled property at a certain time.
* @param timestamp the time the control-change is scheduled for
* @param value the control-value
* @returns FALSE if the values couldn't be set, TRUE otherwise.
*/
set(timestamp: Gst.ClockTime, value: number): boolean;
// Conflicted with GObject.Object.set
set(...args: never[]): any;
/**
* Sets multiple timed values at once.
* @param timedvalues a list with #GstTimedValue items
* @returns FALSE if the values couldn't be set, TRUE otherwise.
*/
set_from_list(timedvalues: Gst.TimedValue[]): boolean;
/**
* Used to remove the value of given controller-handled property at a certain
* time.
* @param timestamp the time the control-change should be removed from
* @returns FALSE if the value couldn't be unset (i.e. not found, TRUE otherwise.
*/
unset(timestamp: Gst.ClockTime): boolean;
/**
* Used to remove all time-stamped values of given controller-handled property
*/
unset_all(): void;
}
namespace TriggerControlSource {
// Constructor properties interface
interface ConstructorProps extends TimedValueControlSource.ConstructorProps {
tolerance: number;
}
}
/**
* #GstTriggerControlSource is a #GstControlSource, that returns values from user-given
* control points. It allows for a tolerance on the time-stamps.
*
* To use #GstTriggerControlSource get a new instance by calling
* gst_trigger_control_source_new(), bind it to a #GParamSpec and set some
* control points by calling gst_timed_value_control_source_set().
*
* All functions are MT-safe.
*/
class TriggerControlSource extends TimedValueControlSource {
static $gtype: GObject.GType<TriggerControlSource>;
// Properties
get tolerance(): number;
set tolerance(val: number);
// Constructors
constructor(properties?: Partial<TriggerControlSource.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](): TriggerControlSource;
}
type ARGBControlBindingClass = typeof ARGBControlBinding;
/**
* An internal structure for value+time and various temporary
* values used for interpolation. This "inherits" from
* GstTimedValue.
*/
class ControlPoint {
static $gtype: GObject.GType<ControlPoint>;
// Fields
timestamp: Gst.ClockTime;
value: number;
// Constructors
constructor(
properties?: Partial<{
timestamp: Gst.ClockTime;
value: number;
}>,
);
_init(...args: any[]): void;
// Methods
/**
* Copies a #GstControlPoint
* @returns A copy of @cp
*/
copy(): ControlPoint;
/**
* Frees all data allocated by a #GstControlPoint instance.
*/
free(): void;
}
type DirectControlBindingClass = typeof DirectControlBinding;
type InterpolationControlSourceClass = typeof InterpolationControlSource;
abstract class InterpolationControlSourcePrivate {
static $gtype: GObject.GType<InterpolationControlSourcePrivate>;
// Constructors
_init(...args: any[]): void;
}
type LFOControlSourceClass = typeof LFOControlSource;
abstract class LFOControlSourcePrivate {
static $gtype: GObject.GType<LFOControlSourcePrivate>;
// Constructors
_init(...args: any[]): void;
}
type ProxyControlBindingClass = typeof ProxyControlBinding;
type TimedValueControlSourceClass = typeof TimedValueControlSource;
abstract class TimedValueControlSourcePrivate {
static $gtype: GObject.GType<TimedValueControlSourcePrivate>;
// Constructors
_init(...args: any[]): void;
}
type TriggerControlSourceClass = typeof TriggerControlSource;
abstract class TriggerControlSourcePrivate {
static $gtype: GObject.GType<TriggerControlSourcePrivate>;
// Constructors
_init(...args: any[]): void;
}
/**
* Name of the imported GIR library
* `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
*/
const __name__: string;
/**
* Version of the imported GIR library
* `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
*/
const __version__: string;
}
export default GstController;
}
declare module 'gi://GstController' {
import GstController10 from 'gi://GstController?version=1.0';
export default GstController10;
}
// END