janishutz/dotfiles
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Activity
Files
10a5c775be5b5feaf9919e6096b4b7be5fda1fde
dotfiles/configs/userland/ags/@girs/evinceview-3.0.d.ts
Janis Hutz 10a5c775be [Build] Start refactor
2026-02-02 16:01:56 +01:00

2499 lines
102 KiB
TypeScript
Raw Blame History

/// <reference path="./gtk-3.0.d.ts" />
/// <reference path="./xlib-2.0.d.ts" />
/// <reference path="./gdk-3.0.d.ts" />
/// <reference path="./cairo-1.0.d.ts" />
/// <reference path="./gobject-2.0.d.ts" />
/// <reference path="./glib-2.0.d.ts" />
/// <reference path="./pango-1.0.d.ts" />
/// <reference path="./harfbuzz-0.0.d.ts" />
/// <reference path="./freetype2-2.0.d.ts" />
/// <reference path="./gio-2.0.d.ts" />
/// <reference path="./gmodule-2.0.d.ts" />
/// <reference path="./gdkpixbuf-2.0.d.ts" />
/// <reference path="./atk-1.0.d.ts" />
/// <reference path="./evincedocument-3.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://EvinceView?version=3.0' {
// Module dependencies
import type Gtk from 'gi://Gtk?version=3.0';
import type xlib from 'gi://xlib?version=2.0';
import type Gdk from 'gi://Gdk?version=3.0';
import type cairo from 'gi://cairo?version=1.0';
import type GObject from 'gi://GObject?version=2.0';
import type GLib from 'gi://GLib?version=2.0';
import type Pango from 'gi://Pango?version=1.0';
import type HarfBuzz from 'gi://HarfBuzz?version=0.0';
import type freetype2 from 'gi://freetype2?version=2.0';
import type Gio from 'gi://Gio?version=2.0';
import type GModule from 'gi://GModule?version=2.0';
import type GdkPixbuf from 'gi://GdkPixbuf?version=2.0';
import type Atk from 'gi://Atk?version=1.0';
import type EvinceDocument from 'gi://EvinceDocument?version=3.0';
export namespace EvinceView {
/**
* EvinceView-3.0
*/
export namespace JobPriority {
export const $gtype: GObject.GType<JobPriority>;
}
enum JobPriority {
PRIORITY_URGENT,
PRIORITY_HIGH,
PRIORITY_LOW,
PRIORITY_NONE,
N_PRIORITIES,
}
export namespace JobRunMode {
export const $gtype: GObject.GType<JobRunMode>;
}
enum JobRunMode {
THREAD,
MAIN_LOOP,
}
export namespace JobThumbnailFormat {
export const $gtype: GObject.GType<JobThumbnailFormat>;
}
enum JobThumbnailFormat {
PIXBUF,
SURFACE,
}
export namespace PageLayout {
export const $gtype: GObject.GType<PageLayout>;
}
enum PageLayout {
SINGLE,
DUAL,
AUTOMATIC,
}
export namespace SizingMode {
export const $gtype: GObject.GType<SizingMode>;
}
enum SizingMode {
/**
* Since: 3.8
*/
FIT_PAGE,
/**
* Same as %EV_SIZING_FIT_PAGE. Deprecated:
*/
BEST_FIT,
FIT_WIDTH,
FREE,
/**
* Since: 3.8
*/
AUTOMATIC,
}
const STOCK_ANNOT_SQUIGGLY: string;
const STOCK_ANNOT_TEXT: string;
const STOCK_ATTACHMENT: string;
const STOCK_CLOSE: string;
const STOCK_FIND_UNSUPPORTED: string;
const STOCK_INVERTED_COLORS: string;
const STOCK_OUTLINE: string;
const STOCK_RESIZE_SE: string;
const STOCK_RESIZE_SW: string;
const STOCK_ROTATE_LEFT: string;
const STOCK_ROTATE_RIGHT: string;
const STOCK_RUN_PRESENTATION: string;
const STOCK_SEND_TO: string;
const STOCK_VIEW_CONTINUOUS: string;
const STOCK_VIEW_DUAL: string;
const STOCK_VIEW_SIDEBAR: string;
const STOCK_VISIBLE: string;
const STOCK_ZOOM: string;
const STOCK_ZOOM_PAGE: string;
const STOCK_ZOOM_WIDTH: string;
/**
* Creates a new icon factory, adding the base stock icons to it.
*/
function stock_icons_init(): void;
function stock_icons_set_screen(screen: Gdk.Screen): void;
function stock_icons_shutdown(): void;
export namespace JobPageDataFlags {
export const $gtype: GObject.GType<JobPageDataFlags>;
}
enum JobPageDataFlags {
NONE,
LINKS,
TEXT,
TEXT_MAPPING,
TEXT_LAYOUT,
TEXT_ATTRS,
TEXT_LOG_ATTRS,
IMAGES,
FORMS,
ANNOTS,
MEDIA,
ALL,
}
module DocumentModel {
// Signal callback interfaces
interface PageChanged {
(object: number, p0: number): void;
}
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {
continuous: boolean;
document: EvinceDocument.Document;
dual_odd_left: boolean;
dualOddLeft: boolean;
dual_page: boolean;
dualPage: boolean;
fullscreen: boolean;
inverted_colors: boolean;
invertedColors: boolean;
max_scale: number;
maxScale: number;
min_scale: number;
minScale: number;
page: number;
page_layout: PageLayout;
pageLayout: PageLayout;
rotation: number;
rtl: boolean;
scale: number;
sizing_mode: SizingMode;
sizingMode: SizingMode;
}
}
class DocumentModel extends GObject.Object {
static $gtype: GObject.GType<DocumentModel>;
// Properties
get continuous(): boolean;
set continuous(val: boolean);
get document(): EvinceDocument.Document;
set document(val: EvinceDocument.Document);
get dual_odd_left(): boolean;
set dual_odd_left(val: boolean);
get dualOddLeft(): boolean;
set dualOddLeft(val: boolean);
get dual_page(): boolean;
set dual_page(val: boolean);
get dualPage(): boolean;
set dualPage(val: boolean);
get fullscreen(): boolean;
set fullscreen(val: boolean);
get inverted_colors(): boolean;
set inverted_colors(val: boolean);
get invertedColors(): boolean;
set invertedColors(val: boolean);
get max_scale(): number;
set max_scale(val: number);
get maxScale(): number;
set maxScale(val: number);
get min_scale(): number;
set min_scale(val: number);
get minScale(): number;
set minScale(val: number);
get page(): number;
set page(val: number);
get page_layout(): PageLayout;
set page_layout(val: PageLayout);
get pageLayout(): PageLayout;
set pageLayout(val: PageLayout);
get rotation(): number;
set rotation(val: number);
get rtl(): boolean;
set rtl(val: boolean);
get scale(): number;
set scale(val: number);
get sizing_mode(): SizingMode;
set sizing_mode(val: SizingMode);
get sizingMode(): SizingMode;
set sizingMode(val: SizingMode);
// Constructors
constructor(properties?: Partial<DocumentModel.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](): DocumentModel;
static new_with_document(document: EvinceDocument.Document): DocumentModel;
// 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: 'page-changed', callback: (_source: this, object: number, p0: number) => void): number;
connect_after(
signal: 'page-changed',
callback: (_source: this, object: number, p0: number) => void,
): number;
emit(signal: 'page-changed', object: number, p0: number): void;
// Methods
get_continuous(): boolean;
/**
* Returns the #EvDocument referenced by the model.
* @returns a #EvDocument
*/
get_document(): EvinceDocument.Document;
get_dual_page(): boolean;
get_dual_page_odd_pages_left(): boolean;
get_fullscreen(): boolean;
get_inverted_colors(): boolean;
get_max_scale(): number;
get_min_scale(): number;
get_page(): number;
get_page_layout(): PageLayout;
get_rotation(): number;
get_rtl(): boolean;
get_scale(): number;
get_sizing_mode(): SizingMode;
set_continuous(continuous: boolean): void;
set_document(document: EvinceDocument.Document): void;
/**
* Sets the document model's page layout to %EV_PAGE_LAYOUT_SINGLE or
* %EV_PAGE_LAYOUT_DUAL.
* @param dual_page whether to enable dual page mode
*/
set_dual_page(dual_page: boolean): void;
set_dual_page_odd_pages_left(odd_left: boolean): void;
set_fullscreen(fullscreen: boolean): void;
set_inverted_colors(inverted_colors: boolean): void;
set_max_scale(max_scale: number): void;
set_min_scale(min_scale: number): void;
set_page(page: number): void;
set_page_by_label(page_label: string): void;
/**
* Sets the document model's page layout to `layout`.
* @param layout a #EvPageLayout
*/
set_page_layout(layout: PageLayout | null): void;
set_rotation(rotation: number): void;
set_rtl(rtl: boolean): void;
set_scale(scale: number): void;
set_sizing_mode(mode: SizingMode | null): void;
}
module Job {
// Signal callback interfaces
interface Cancelled {
(): void;
}
interface Finished {
(): void;
}
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {}
}
abstract class Job extends GObject.Object {
static $gtype: GObject.GType<Job>;
// Fields
document: EvinceDocument.Document;
run_mode: JobRunMode;
cancelled: number;
finished: number;
error: GLib.Error;
cancellable: Gio.Cancellable;
idle_finished_id: number;
idle_cancelled_id: number;
// Constructors
constructor(properties?: Partial<Job.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: 'cancelled', callback: (_source: this) => void): number;
connect_after(signal: 'cancelled', callback: (_source: this) => void): number;
emit(signal: 'cancelled'): void;
connect(signal: 'finished', callback: (_source: this) => void): number;
connect_after(signal: 'finished', callback: (_source: this) => void): number;
emit(signal: 'finished'): void;
// Static methods
static scheduler_get_running_thread_job(): Job;
/**
* Synchronously waits until all jobs are done.
* Remember that main loop is not running already probably.
*/
static scheduler_wait(): void;
// Virtual methods
vfunc_cancelled(): void;
vfunc_finished(): void;
vfunc_run(): boolean;
// Methods
cancel(): void;
failed(error: GLib.Error): void;
get_run_mode(): JobRunMode;
is_failed(): boolean;
is_finished(): boolean;
run(): boolean;
scheduler_push_job(priority: JobPriority | null): void;
scheduler_update_job(priority: JobPriority | null): void;
set_run_mode(run_mode: JobRunMode | null): void;
succeeded(): void;
}
module JobAnnots {
// Constructor properties interface
interface ConstructorProps extends Job.ConstructorProps {}
}
class JobAnnots extends Job {
static $gtype: GObject.GType<JobAnnots>;
// Fields
annots: any[];
// Constructors
constructor(properties?: Partial<JobAnnots.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](document: EvinceDocument.Document): JobAnnots;
}
module JobAttachments {
// Constructor properties interface
interface ConstructorProps extends Job.ConstructorProps {}
}
class JobAttachments extends Job {
static $gtype: GObject.GType<JobAttachments>;
// Fields
attachments: any[];
// Constructors
constructor(properties?: Partial<JobAttachments.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](document: EvinceDocument.Document): JobAttachments;
}
module JobExport {
// Constructor properties interface
interface ConstructorProps extends Job.ConstructorProps {}
}
class JobExport extends Job {
static $gtype: GObject.GType<JobExport>;
// Fields
page: number;
rc: EvinceDocument.RenderContext;
// Constructors
constructor(properties?: Partial<JobExport.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](document: EvinceDocument.Document): JobExport;
// Methods
set_page(page: number): void;
}
module JobFind {
// Signal callback interfaces
interface Updated {
(object: number): void;
}
// Constructor properties interface
interface ConstructorProps extends Job.ConstructorProps {}
}
class JobFind extends Job {
static $gtype: GObject.GType<JobFind>;
// Fields
start_page: number;
current_page: number;
n_pages: number;
pages: any[];
text: string;
case_sensitive: boolean;
options: EvinceDocument.FindOptions;
// Constructors
constructor(properties?: Partial<JobFind.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](
document: EvinceDocument.Document,
start_page: number,
n_pages: number,
text: string,
case_sensitive: boolean,
): JobFind;
// 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: 'updated', callback: (_source: this, object: number) => void): number;
connect_after(signal: 'updated', callback: (_source: this, object: number) => void): number;
emit(signal: 'updated', object: number): void;
// Virtual methods
vfunc_updated(page: number): void;
// Methods
/**
* This is similar to ev_job_find_get_n_results() but it takes
* care to treat any multi-line matches as being only one result.
* @param page number of the page we want to count its match results.
* @returns total number of match results in @page
*/
get_n_main_results(page: number): number;
get_n_results(pages: number): number;
get_options(): EvinceDocument.FindOptions;
get_progress(): number;
has_results(): boolean;
set_options(options: EvinceDocument.FindOptions | null): void;
}
module JobFonts {
// Signal callback interfaces
interface Updated {
(object: number): void;
}
// Constructor properties interface
interface ConstructorProps extends Job.ConstructorProps {}
}
class JobFonts extends Job {
static $gtype: GObject.GType<JobFonts>;
// Fields
scan_completed: boolean;
// Constructors
constructor(properties?: Partial<JobFonts.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](document: EvinceDocument.Document): JobFonts;
// 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: 'updated', callback: (_source: this, object: number) => void): number;
connect_after(signal: 'updated', callback: (_source: this, object: number) => void): number;
emit(signal: 'updated', object: number): void;
// Virtual methods
vfunc_updated(progress: number): void;
}
module JobLayers {
// Constructor properties interface
interface ConstructorProps extends Job.ConstructorProps {}
}
class JobLayers extends Job {
static $gtype: GObject.GType<JobLayers>;
// Fields
model: Gtk.TreeModel;
// Constructors
constructor(properties?: Partial<JobLayers.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](document: EvinceDocument.Document): JobLayers;
}
module JobLinks {
// Constructor properties interface
interface ConstructorProps extends Job.ConstructorProps {}
}
class JobLinks extends Job {
static $gtype: GObject.GType<JobLinks>;
// Fields
model: Gtk.TreeModel;
// Constructors
constructor(properties?: Partial<JobLinks.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](document: EvinceDocument.Document): JobLinks;
// Methods
/**
* Get a #GtkTreeModel loaded with the links
* @returns The #GtkTreeModel loaded
*/
get_model(): Gtk.TreeModel;
}
module JobLoad {
// Constructor properties interface
interface ConstructorProps extends Job.ConstructorProps {}
}
class JobLoad extends Job {
static $gtype: GObject.GType<JobLoad>;
// Fields
uri: string;
password: string;
// Constructors
constructor(properties?: Partial<JobLoad.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](uri: string): JobLoad;
// Methods
set_password(password: string): void;
set_uri(uri: string): void;
}
module JobLoadFd {
// Constructor properties interface
interface ConstructorProps extends Job.ConstructorProps {}
}
/**
* A job class to load a #EvDocument from a file descriptor
* referring to a regular file.
*/
class JobLoadFd extends Job {
static $gtype: GObject.GType<JobLoadFd>;
// Fields
mime_type: string;
password: string;
fd: number;
flags: EvinceDocument.DocumentLoadFlags;
// Constructors
constructor(properties?: Partial<JobLoadFd.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](fd: number, mime_type: string, flags: EvinceDocument.DocumentLoadFlags): JobLoadFd;
static new_take(fd: number, mime_type: string, flags: EvinceDocument.DocumentLoadFlags): JobLoadFd;
// Methods
/**
* Sets `fd` as the file descriptor in `job`. If duplicating `fd` fails,
* returns %FALSE with `error` filled in.
* @param fd a file descriptor
* @returns %TRUE if the file descriptor could be set
*/
set_fd(fd: number): boolean;
set_load_flags(flags: EvinceDocument.DocumentLoadFlags | null): void;
set_mime_type(mime_type: string): void;
set_password(password: string): void;
/**
* Sets `fd` as the file descriptor in `job`.
* Note that `job` takes ownership of `fd;` you must not do anything
* with it afterwards.
* @param fd a file descriptor
*/
take_fd(fd: number): void;
}
module JobLoadGFile {
// Constructor properties interface
interface ConstructorProps extends Job.ConstructorProps {}
}
/**
* A job class to load a #EvDocument from a #GFile.
*/
class JobLoadGFile extends Job {
static $gtype: GObject.GType<JobLoadGFile>;
// Fields
password: string;
gfile: Gio.File;
flags: EvinceDocument.DocumentLoadFlags;
// Constructors
constructor(properties?: Partial<JobLoadGFile.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](gfile: Gio.File, flags: EvinceDocument.DocumentLoadFlags): JobLoadGFile;
// Methods
set_gfile(gfile: Gio.File): void;
set_load_flags(flags: EvinceDocument.DocumentLoadFlags | null): void;
set_password(password: string): void;
}
module JobLoadStream {
// Constructor properties interface
interface ConstructorProps extends Job.ConstructorProps {}
}
/**
* A job class to load a #EvDocument from a #GInputStream.
*/
class JobLoadStream extends Job {
static $gtype: GObject.GType<JobLoadStream>;
// Fields
password: string;
stream: Gio.InputStream;
flags: EvinceDocument.DocumentLoadFlags;
// Constructors
constructor(properties?: Partial<JobLoadStream.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](stream: Gio.InputStream, flags: EvinceDocument.DocumentLoadFlags): JobLoadStream;
// Methods
set_load_flags(flags: EvinceDocument.DocumentLoadFlags | null): void;
set_mime_type(mime_type: string): void;
set_password(password: string): void;
set_stream(stream: Gio.InputStream): void;
}
module JobPageData {
// Constructor properties interface
interface ConstructorProps extends Job.ConstructorProps {}
}
class JobPageData extends Job {
static $gtype: GObject.GType<JobPageData>;
// Fields
page: number;
flags: JobPageDataFlags;
text: string;
text_layout: EvinceDocument.Rectangle;
text_layout_length: number;
text_log_attrs: Pango.LogAttr;
text_log_attrs_length: number;
// Constructors
constructor(properties?: Partial<JobPageData.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](document: EvinceDocument.Document, page: number, flags: JobPageDataFlags): JobPageData;
}
module JobPrint {
// Constructor properties interface
interface ConstructorProps extends Job.ConstructorProps {}
}
class JobPrint extends Job {
static $gtype: GObject.GType<JobPrint>;
// Fields
page: number;
// Constructors
constructor(properties?: Partial<JobPrint.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](document: EvinceDocument.Document): JobPrint;
// Methods
set_cairo(cr: cairo.Context): void;
set_page(page: number): void;
}
module JobRender {
// Constructor properties interface
interface ConstructorProps extends Job.ConstructorProps {}
}
class JobRender extends Job {
static $gtype: GObject.GType<JobRender>;
// Fields
page: number;
rotation: number;
scale: number;
page_ready: boolean;
target_width: number;
target_height: number;
include_selection: boolean;
selection_points: EvinceDocument.Rectangle;
selection_style: EvinceDocument.SelectionStyle;
base: Gdk.Color;
text: Gdk.Color;
// Constructors
constructor(properties?: Partial<JobRender.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](
document: EvinceDocument.Document,
page: number,
rotation: number,
scale: number,
width: number,
height: number,
): JobRender;
// Methods
set_selection_info(
selection_points: EvinceDocument.Rectangle,
selection_style: EvinceDocument.SelectionStyle | null,
text: Gdk.Color,
base: Gdk.Color,
): void;
}
module JobSave {
// Constructor properties interface
interface ConstructorProps extends Job.ConstructorProps {}
}
class JobSave extends Job {
static $gtype: GObject.GType<JobSave>;
// Fields
uri: string;
document_uri: string;
// Constructors
constructor(properties?: Partial<JobSave.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](document: EvinceDocument.Document, uri: string, document_uri: string): JobSave;
}
module JobThumbnail {
// Constructor properties interface
interface ConstructorProps extends Job.ConstructorProps {}
}
class JobThumbnail extends Job {
static $gtype: GObject.GType<JobThumbnail>;
// Fields
page: number;
rotation: number;
scale: number;
target_width: number;
target_height: number;
thumbnail: GdkPixbuf.Pixbuf;
has_frame: boolean;
format: JobThumbnailFormat;
// Constructors
constructor(properties?: Partial<JobThumbnail.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](
document: EvinceDocument.Document,
page: number,
rotation: number,
scale: number,
): JobThumbnail;
static new_with_target_size(
document: EvinceDocument.Document,
page: number,
rotation: number,
target_width: number,
target_height: number,
): JobThumbnail;
// Methods
set_has_frame(has_frame: boolean): void;
/**
* Set the desired output format for the generated thumbnail
* @param format a #EvJobThumbnailFormat
*/
set_output_format(format: JobThumbnailFormat | null): void;
}
module PrintOperation {
// Signal callback interfaces
interface BeginPrint {
(): void;
}
interface Done {
(object: Gtk.PrintOperationResult): void;
}
interface StatusChanged {
(): void;
}
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {
document: EvinceDocument.Document;
}
}
abstract class PrintOperation extends GObject.Object {
static $gtype: GObject.GType<PrintOperation>;
// Properties
set document(val: EvinceDocument.Document);
// Constructors
constructor(properties?: Partial<PrintOperation.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](document: EvinceDocument.Document): PrintOperation;
// 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: 'begin-print', callback: (_source: this) => void): number;
connect_after(signal: 'begin-print', callback: (_source: this) => void): number;
emit(signal: 'begin-print'): void;
connect(signal: 'done', callback: (_source: this, object: Gtk.PrintOperationResult) => void): number;
connect_after(signal: 'done', callback: (_source: this, object: Gtk.PrintOperationResult) => void): number;
emit(signal: 'done', object: Gtk.PrintOperationResult): void;
connect(signal: 'status-changed', callback: (_source: this) => void): number;
connect_after(signal: 'status-changed', callback: (_source: this) => void): number;
emit(signal: 'status-changed'): void;
// Static methods
static exists_for_document(document: EvinceDocument.Document): boolean;
// Methods
cancel(): void;
get_default_page_setup(): Gtk.PageSetup;
get_embed_page_setup(): boolean;
get_error(): void;
get_job_name(): string;
get_print_settings(): Gtk.PrintSettings;
get_progress(): number;
get_status(): string;
run(parent: Gtk.Window): void;
set_current_page(current_page: number): void;
set_default_page_setup(page_setup: Gtk.PageSetup): void;
set_embed_page_setup(embed: boolean): void;
set_job_name(job_name: string): void;
set_print_settings(print_settings: Gtk.PrintSettings): void;
}
module View {
// Signal callback interfaces
interface Activate {
(): void;
}
interface AnnotAdded {
(object: EvinceDocument.Annotation): void;
}
interface AnnotCancelAdd {
(): void;
}
interface AnnotChanged {
(object: EvinceDocument.Annotation): void;
}
interface AnnotRemoved {
(object: EvinceDocument.Annotation): void;
}
interface CursorMoved {
(object: number, p0: number): void;
}
interface ExternalLink {
(object: GObject.Object): void;
}
interface HandleLink {
(object: number, p0: GObject.Object): void;
}
interface LayersChanged {
(): void;
}
interface MoveCursor {
(object: Gtk.MovementStep, p0: number, p1: boolean): boolean;
}
interface Popup {
(object?: any | null): void;
}
interface Scroll {
(object: Gtk.ScrollType, p0: Gtk.Orientation): void;
}
interface SelectionChanged {
(): void;
}
interface SyncSource {
(object: EvinceDocument.SourceLink): void;
}
// Constructor properties interface
interface ConstructorProps
extends Gtk.Container.ConstructorProps,
Atk.ImplementorIface.ConstructorProps,
Gtk.Buildable.ConstructorProps,
Gtk.Scrollable.ConstructorProps {
can_zoom_in: boolean;
canZoomIn: boolean;
can_zoom_out: boolean;
canZoomOut: boolean;
is_loading: boolean;
isLoading: boolean;
}
}
class View extends Gtk.Container implements Atk.ImplementorIface, Gtk.Buildable, Gtk.Scrollable {
static $gtype: GObject.GType<View>;
// Properties
get can_zoom_in(): boolean;
get canZoomIn(): boolean;
get can_zoom_out(): boolean;
get canZoomOut(): boolean;
/**
* Allows to implement a custom notification system.
*/
get is_loading(): boolean;
/**
* Allows to implement a custom notification system.
*/
get isLoading(): boolean;
// Constructors
constructor(properties?: Partial<View.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](): View;
// 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: 'activate', callback: (_source: this) => void): number;
connect_after(signal: 'activate', callback: (_source: this) => void): number;
emit(signal: 'activate'): void;
connect(
signal: 'annot-added',
callback: (_source: this, object: EvinceDocument.Annotation) => void,
): number;
connect_after(
signal: 'annot-added',
callback: (_source: this, object: EvinceDocument.Annotation) => void,
): number;
emit(signal: 'annot-added', object: EvinceDocument.Annotation): void;
connect(signal: 'annot-cancel-add', callback: (_source: this) => void): number;
connect_after(signal: 'annot-cancel-add', callback: (_source: this) => void): number;
emit(signal: 'annot-cancel-add'): void;
connect(
signal: 'annot-changed',
callback: (_source: this, object: EvinceDocument.Annotation) => void,
): number;
connect_after(
signal: 'annot-changed',
callback: (_source: this, object: EvinceDocument.Annotation) => void,
): number;
emit(signal: 'annot-changed', object: EvinceDocument.Annotation): void;
connect(
signal: 'annot-removed',
callback: (_source: this, object: EvinceDocument.Annotation) => void,
): number;
connect_after(
signal: 'annot-removed',
callback: (_source: this, object: EvinceDocument.Annotation) => void,
): number;
emit(signal: 'annot-removed', object: EvinceDocument.Annotation): void;
connect(signal: 'cursor-moved', callback: (_source: this, object: number, p0: number) => void): number;
connect_after(
signal: 'cursor-moved',
callback: (_source: this, object: number, p0: number) => void,
): number;
emit(signal: 'cursor-moved', object: number, p0: number): void;
connect(signal: 'external-link', callback: (_source: this, object: GObject.Object) => void): number;
connect_after(signal: 'external-link', callback: (_source: this, object: GObject.Object) => void): number;
emit(signal: 'external-link', object: GObject.Object): void;
connect(
signal: 'handle-link',
callback: (_source: this, object: number, p0: GObject.Object) => void,
): number;
connect_after(
signal: 'handle-link',
callback: (_source: this, object: number, p0: GObject.Object) => void,
): number;
emit(signal: 'handle-link', object: number, p0: GObject.Object): void;
connect(signal: 'layers-changed', callback: (_source: this) => void): number;
connect_after(signal: 'layers-changed', callback: (_source: this) => void): number;
emit(signal: 'layers-changed'): void;
connect(
signal: 'move-cursor',
callback: (_source: this, object: Gtk.MovementStep, p0: number, p1: boolean) => boolean,
): number;
connect_after(
signal: 'move-cursor',
callback: (_source: this, object: Gtk.MovementStep, p0: number, p1: boolean) => boolean,
): number;
emit(signal: 'move-cursor', object: Gtk.MovementStep, p0: number, p1: boolean): void;
connect(signal: 'popup', callback: (_source: this, object: any | null) => void): number;
connect_after(signal: 'popup', callback: (_source: this, object: any | null) => void): number;
emit(signal: 'popup', object?: any | null): void;
connect(
signal: 'scroll',
callback: (_source: this, object: Gtk.ScrollType, p0: Gtk.Orientation) => void,
): number;
connect_after(
signal: 'scroll',
callback: (_source: this, object: Gtk.ScrollType, p0: Gtk.Orientation) => void,
): number;
emit(signal: 'scroll', object: Gtk.ScrollType, p0: Gtk.Orientation): void;
connect(signal: 'selection-changed', callback: (_source: this) => void): number;
connect_after(signal: 'selection-changed', callback: (_source: this) => void): number;
emit(signal: 'selection-changed'): void;
connect(
signal: 'sync-source',
callback: (_source: this, object: EvinceDocument.SourceLink) => void,
): number;
connect_after(
signal: 'sync-source',
callback: (_source: this, object: EvinceDocument.SourceLink) => void,
): number;
emit(signal: 'sync-source', object: EvinceDocument.SourceLink): void;
// Methods
/**
* Adds a Text Markup annotation (defaulting to a 'highlight' one) to
* the currently selected text on the document.
*
* When the selected text spans more than one page, it will add a
* corresponding annotation for each page that contains selected text.
* @returns %TRUE if annotations were added successfully, %FALSE otherwise.
*/
add_text_markup_annotation_for_selected_text(): boolean;
autoscroll_start(): void;
autoscroll_stop(): void;
begin_add_annotation(annot_type: EvinceDocument.AnnotationType | null): void;
cancel_add_annotation(): void;
copy(): void;
copy_link_address(action: EvinceDocument.LinkAction): void;
current_event_is_type(type: Gdk.EventType | null): boolean;
find_cancel(): void;
find_next(): void;
find_previous(): void;
/**
* Restart the current search operation from the given `page`.
* @param page a page index
*/
find_restart(page: number): void;
find_search_changed(): void;
find_set_highlight_search(value: boolean): void;
/**
* FIXME
* @param page
* @param result
*/
find_set_result(page: number, result: number): void;
find_started(job: JobFind): void;
focus_annotation(annot_mapping: EvinceDocument.Mapping): void;
get_allow_links_change_zoom(): boolean;
get_enable_spellchecking(): boolean;
get_has_selection(): boolean;
get_page_extents(page: number, page_area: Gdk.Rectangle, border: Gtk.Border): boolean;
get_page_extents_for_border(page: number, border: Gtk.Border, page_area: Gdk.Rectangle): boolean;
/**
* Returns a pointer to a constant string containing the selected
* text in the view.
*
* The value returned may be NULL if there is no selected text.
* @returns The string representing selected text.
*/
get_selected_text(): string;
handle_link(link: EvinceDocument.Link): void;
hide_cursor(): void;
highlight_forward_search(link: EvinceDocument.SourceLink): void;
is_caret_navigation_enabled(): boolean;
next_page(): boolean;
previous_page(): boolean;
reload(): void;
remove_annotation(annot: EvinceDocument.Annotation): void;
scroll(scroll: Gtk.ScrollType | null, horizontal: boolean): void;
select_all(): void;
set_allow_links_change_zoom(allowed: boolean): void;
set_caret_cursor_position(page: number, offset: number): void;
/**
* Enables or disables caret navigation mode for the document.
* @param enabled whether to enable caret navigation mode
*/
set_caret_navigation_enabled(enabled: boolean): void;
set_enable_spellchecking(spellcheck: boolean): void;
set_loading(loading: boolean): void;
set_model(model: DocumentModel): void;
/**
* Sets the maximum size in bytes that will be used to cache
* rendered pages. Use 0 to disable caching rendered pages.
*
* Note that this limit doesn't affect the current visible page range,
* which will always be rendered. In order to limit the total memory used
* you have to use ev_document_model_set_max_scale() too.
* @param cache_size size in bytes
*/
set_page_cache_size(cache_size: number): void;
show_cursor(): void;
supports_caret_navigation(): boolean;
zoom_in(): void;
zoom_out(): void;
// Inherited properties
/**
* Horizontal #GtkAdjustment of the scrollable widget. This adjustment is
* shared between the scrollable widget and its parent.
*/
get hadjustment(): Gtk.Adjustment;
set hadjustment(val: Gtk.Adjustment);
/**
* Determines whether horizontal scrolling should start once the scrollable
* widget is allocated less than its minimum width or less than its natural width.
*/
get hscroll_policy(): Gtk.ScrollablePolicy;
set hscroll_policy(val: Gtk.ScrollablePolicy);
/**
* Determines whether horizontal scrolling should start once the scrollable
* widget is allocated less than its minimum width or less than its natural width.
*/
get hscrollPolicy(): Gtk.ScrollablePolicy;
set hscrollPolicy(val: Gtk.ScrollablePolicy);
/**
* Verical #GtkAdjustment of the scrollable widget. This adjustment is shared
* between the scrollable widget and its parent.
*/
get vadjustment(): Gtk.Adjustment;
set vadjustment(val: Gtk.Adjustment);
/**
* Determines whether vertical scrolling should start once the scrollable
* widget is allocated less than its minimum height or less than its natural height.
*/
get vscroll_policy(): Gtk.ScrollablePolicy;
set vscroll_policy(val: Gtk.ScrollablePolicy);
/**
* Determines whether vertical scrolling should start once the scrollable
* widget is allocated less than its minimum height or less than its natural height.
*/
get vscrollPolicy(): Gtk.ScrollablePolicy;
set vscrollPolicy(val: Gtk.ScrollablePolicy);
// Inherited methods
/**
* Returns the size of a non-scrolling border around the
* outside of the scrollable. An example for this would
* be treeview headers. GTK+ can use this information to
* display overlayed graphics, like the overshoot indication,
* at the right position.
* @returns %TRUE if @border has been set
*/
get_border(): [boolean, Gtk.Border];
/**
* Retrieves the #GtkAdjustment used for horizontal scrolling.
* @returns horizontal #GtkAdjustment.
*/
get_hadjustment(): Gtk.Adjustment;
/**
* Gets the horizontal #GtkScrollablePolicy.
* @returns The horizontal #GtkScrollablePolicy.
*/
get_hscroll_policy(): Gtk.ScrollablePolicy;
/**
* Retrieves the #GtkAdjustment used for vertical scrolling.
* @returns vertical #GtkAdjustment.
*/
get_vadjustment(): Gtk.Adjustment;
/**
* Gets the vertical #GtkScrollablePolicy.
* @returns The vertical #GtkScrollablePolicy.
*/
get_vscroll_policy(): Gtk.ScrollablePolicy;
/**
* Sets the horizontal adjustment of the #GtkScrollable.
* @param hadjustment a #GtkAdjustment
*/
set_hadjustment(hadjustment?: Gtk.Adjustment | null): void;
/**
* Sets the #GtkScrollablePolicy to determine whether
* horizontal scrolling should start below the minimum width or
* below the natural width.
* @param policy the horizontal #GtkScrollablePolicy
*/
set_hscroll_policy(policy: Gtk.ScrollablePolicy | null): void;
/**
* Sets the vertical adjustment of the #GtkScrollable.
* @param vadjustment a #GtkAdjustment
*/
set_vadjustment(vadjustment?: Gtk.Adjustment | null): void;
/**
* Sets the #GtkScrollablePolicy to determine whether
* vertical scrolling should start below the minimum height or
* below the natural height.
* @param policy the vertical #GtkScrollablePolicy
*/
set_vscroll_policy(policy: Gtk.ScrollablePolicy | null): void;
/**
* Returns the size of a non-scrolling border around the
* outside of the scrollable. An example for this would
* be treeview headers. GTK+ can use this information to
* display overlayed graphics, like the overshoot indication,
* at the right position.
*/
vfunc_get_border(): [boolean, Gtk.Border];
/**
* Creates a binding between `source_property` on `source` and `target_property`
* on `target`.
*
* Whenever the `source_property` is changed the `target_property` is
* updated using the same value. For instance:
*
*
* ```c
* g_object_bind_property (action, "active", widget, "sensitive", 0);
* ```
*
*
* Will result in the "sensitive" property of the widget #GObject instance to be
* updated with the same value of the "active" property of the action #GObject
* instance.
*
* If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
* if `target_property` on `target` changes then the `source_property` on `source`
* will be updated as well.
*
* The binding will automatically be removed when either the `source` or the
* `target` instances are finalized. To remove the binding without affecting the
* `source` and the `target` you can just call g_object_unref() on the returned
* #GBinding instance.
*
* Removing the binding by calling g_object_unref() on it must only be done if
* the binding, `source` and `target` are only used from a single thread and it
* is clear that both `source` and `target` outlive the binding. Especially it
* is not safe to rely on this if the binding, `source` or `target` can be
* finalized from different threads. Keep another reference to the binding and
* use g_binding_unbind() instead to be on the safe side.
*
* A #GObject can have multiple bindings.
* @param source_property the property on @source to bind
* @param target the target #GObject
* @param target_property the property on @target to bind
* @param flags flags to pass to #GBinding
* @returns the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero.
*/
bind_property(
source_property: string,
target: GObject.Object,
target_property: string,
flags: GObject.BindingFlags | null,
): GObject.Binding;
/**
* Complete version of g_object_bind_property().
*
* Creates a binding between `source_property` on `source` and `target_property`
* on `target,` allowing you to set the transformation functions to be used by
* the binding.
*
* If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
* if `target_property` on `target` changes then the `source_property` on `source`
* will be updated as well. The `transform_from` function is only used in case
* of bidirectional bindings, otherwise it will be ignored
*
* The binding will automatically be removed when either the `source` or the
* `target` instances are finalized. This will release the reference that is
* being held on the #GBinding instance; if you want to hold on to the
* #GBinding instance, you will need to hold a reference to it.
*
* To remove the binding, call g_binding_unbind().
*
* A #GObject can have multiple bindings.
*
* The same `user_data` parameter will be used for both `transform_to`
* and `transform_from` transformation functions; the `notify` function will
* be called once, when the binding is removed. If you need different data
* for each transformation function, please use
* g_object_bind_property_with_closures() instead.
* @param source_property the property on @source to bind
* @param target the target #GObject
* @param target_property the property on @target to bind
* @param flags flags to pass to #GBinding
* @param transform_to the transformation function from the @source to the @target, or %NULL to use the default
* @param transform_from the transformation function from the @target to the @source, or %NULL to use the default
* @param notify a function to call when disposing the binding, to free resources used by the transformation functions, or %NULL if not required
* @returns the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero.
*/
bind_property_full(
source_property: string,
target: GObject.Object,
target_property: string,
flags: GObject.BindingFlags | null,
transform_to?: GObject.BindingTransformFunc | null,
transform_from?: GObject.BindingTransformFunc | null,
notify?: GLib.DestroyNotify | null,
): GObject.Binding;
// Conflicted with GObject.Object.bind_property_full
bind_property_full(...args: never[]): any;
/**
* This function is intended for #GObject implementations to re-enforce
* a [floating][floating-ref] object reference. Doing this is seldom
* required: all #GInitiallyUnowneds are created with a floating reference
* which usually just needs to be sunken by calling g_object_ref_sink().
*/
force_floating(): void;
/**
* Increases the freeze count on `object`. If the freeze count is
* non-zero, the emission of "notify" signals on `object` is
* stopped. The signals are queued until the freeze count is decreased
* to zero. Duplicate notifications are squashed so that at most one
* #GObject::notify signal is emitted for each property modified while the
* object is frozen.
*
* This is necessary for accessors that modify multiple properties to prevent
* premature notification while the object is still being modified.
*/
freeze_notify(): void;
/**
* Gets a named field from the objects table of associations (see g_object_set_data()).
* @param key name of the key for that association
* @returns the data if found, or %NULL if no such data exists.
*/
get_data(key: string): any | null;
get_property(property_name: string): any;
/**
* This function gets back user data pointers stored via
* g_object_set_qdata().
* @param quark A #GQuark, naming the user data pointer
* @returns The user data pointer set, or %NULL
*/
get_qdata(quark: GLib.Quark): any | null;
/**
* Gets `n_properties` properties for an `object`.
* Obtained properties will be set to `values`. All properties must be valid.
* Warnings will be emitted and undefined behaviour may result if invalid
* properties are passed in.
* @param names the names of each property to get
* @param values the values of each property to get
*/
getv(names: string[], values: (GObject.Value | any)[]): void;
/**
* Checks whether `object` has a [floating][floating-ref] reference.
* @returns %TRUE if @object has a floating reference
*/
is_floating(): boolean;
/**
* Emits a "notify" signal for the property `property_name` on `object`.
*
* When possible, eg. when signaling a property change from within the class
* that registered the property, you should use g_object_notify_by_pspec()
* instead.
*
* Note that emission of the notify signal may be blocked with
* g_object_freeze_notify(). In this case, the signal emissions are queued
* and will be emitted (in reverse order) when g_object_thaw_notify() is
* called.
* @param property_name the name of a property installed on the class of @object.
*/
notify(property_name: string): void;
/**
* Emits a "notify" signal for the property specified by `pspec` on `object`.
*
* This function omits the property name lookup, hence it is faster than
* g_object_notify().
*
* One way to avoid using g_object_notify() from within the
* class that registered the properties, and using g_object_notify_by_pspec()
* instead, is to store the GParamSpec used with
* g_object_class_install_property() inside a static array, e.g.:
*
*
* ```c
* typedef enum
* {
* PROP_FOO = 1,
* PROP_LAST
* } MyObjectProperty;
*
* static GParamSpec *properties[PROP_LAST];
*
* static void
* my_object_class_init (MyObjectClass *klass)
* {
* properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
* 0, 100,
* 50,
* G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
* g_object_class_install_property (gobject_class,
* PROP_FOO,
* properties[PROP_FOO]);
* }
* ```
*
*
* and then notify a change on the "foo" property with:
*
*
* ```c
* g_object_notify_by_pspec (self, properties[PROP_FOO]);
* ```
*
* @param pspec the #GParamSpec of a property installed on the class of @object.
*/
notify_by_pspec(pspec: GObject.ParamSpec): void;
/**
* Increases the reference count of `object`.
*
* Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
* of `object` will be propagated to the return type (using the GCC typeof()
* extension), so any casting the caller needs to do on the return type must be
* explicit.
* @returns the same @object
*/
ref(): GObject.Object;
/**
* Increase the reference count of `object,` and possibly remove the
* [floating][floating-ref] reference, if `object` has a floating reference.
*
* In other words, if the object is floating, then this call "assumes
* ownership" of the floating reference, converting it to a normal
* reference by clearing the floating flag while leaving the reference
* count unchanged. If the object is not floating, then this call
* adds a new normal reference increasing the reference count by one.
*
* Since GLib 2.56, the type of `object` will be propagated to the return type
* under the same conditions as for g_object_ref().
* @returns @object
*/
ref_sink(): GObject.Object;
/**
* Releases all references to other objects. This can be used to break
* reference cycles.
*
* This function should only be called from object system implementations.
*/
run_dispose(): void;
/**
* Each object carries around a table of associations from
* strings to pointers. This function lets you set an association.
*
* If the object already had an association with that name,
* the old association will be destroyed.
*
* Internally, the `key` is converted to a #GQuark using g_quark_from_string().
* This means a copy of `key` is kept permanently (even after `object` has been
* finalized) — so it is recommended to only use a small, bounded set of values
* for `key` in your program, to avoid the #GQuark storage growing unbounded.
* @param key name of the key
* @param data data to associate with that key
*/
set_data(key: string, data?: any | null): void;
set_property(property_name: string, value: any): void;
/**
* Remove a specified datum from the object's data associations,
* without invoking the association's destroy handler.
* @param key name of the key
* @returns the data if found, or %NULL if no such data exists.
*/
steal_data(key: string): any | null;
/**
* This function gets back user data pointers stored via
* g_object_set_qdata() and removes the `data` from object
* without invoking its destroy() function (if any was
* set).
* Usually, calling this function is only required to update
* user data pointers with a destroy notifier, for example:
*
* ```c
* void
* object_add_to_user_list (GObject *object,
* const gchar *new_string)
* {
* // the quark, naming the object data
* GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
* // retrieve the old string list
* GList *list = g_object_steal_qdata (object, quark_string_list);
*
* // prepend new string
* list = g_list_prepend (list, g_strdup (new_string));
* // this changed 'list', so we need to set it again
* g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
* }
* static void
* free_string_list (gpointer data)
* {
* GList *node, *list = data;
*
* for (node = list; node; node = node->next)
* g_free (node->data);
* g_list_free (list);
* }
* ```
*
* Using g_object_get_qdata() in the above example, instead of
* g_object_steal_qdata() would have left the destroy function set,
* and thus the partial string list would have been freed upon
* g_object_set_qdata_full().
* @param quark A #GQuark, naming the user data pointer
* @returns The user data pointer set, or %NULL
*/
steal_qdata(quark: GLib.Quark): any | null;
/**
* Reverts the effect of a previous call to
* g_object_freeze_notify(). The freeze count is decreased on `object`
* and when it reaches zero, queued "notify" signals are emitted.
*
* Duplicate notifications for each property are squashed so that at most one
* #GObject::notify signal is emitted for each property, in the reverse order
* in which they have been queued.
*
* It is an error to call this function when the freeze count is zero.
*/
thaw_notify(): void;
/**
* Decreases the reference count of `object`. When its reference count
* drops to 0, the object is finalized (i.e. its memory is freed).
*
* If the pointer to the #GObject may be reused in future (for example, if it is
* an instance variable of another object), it is recommended to clear the
* pointer to %NULL rather than retain a dangling pointer to a potentially
* invalid #GObject instance. Use g_clear_object() for this.
*/
unref(): void;
/**
* This function essentially limits the life time of the `closure` to
* the life time of the object. That is, when the object is finalized,
* the `closure` is invalidated by calling g_closure_invalidate() on
* it, in order to prevent invocations of the closure with a finalized
* (nonexisting) object. Also, g_object_ref() and g_object_unref() are
* added as marshal guards to the `closure,` to ensure that an extra
* reference count is held on `object` during invocation of the
* `closure`. Usually, this function will be called on closures that
* use this `object` as closure data.
* @param closure #GClosure to watch
*/
watch_closure(closure: GObject.Closure): void;
/**
* the `constructed` function is called by g_object_new() as the
* final step of the object creation process. At the point of the call, all
* construction properties have been set on the object. The purpose of this
* call is to allow for object initialisation steps that can only be performed
* after construction properties have been set. `constructed` implementors
* should chain up to the `constructed` call of their parent class to allow it
* to complete its initialisation.
*/
vfunc_constructed(): void;
/**
* emits property change notification for a bunch
* of properties. Overriding `dispatch_properties_changed` should be rarely
* needed.
* @param n_pspecs
* @param pspecs
*/
vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
/**
* the `dispose` function is supposed to drop all references to other
* objects, but keep the instance otherwise intact, so that client method
* invocations still work. It may be run multiple times (due to reference
* loops). Before returning, `dispose` should chain up to the `dispose` method
* of the parent class.
*/
vfunc_dispose(): void;
/**
* instance finalization function, should finish the finalization of
* the instance begun in `dispose` and chain up to the `finalize` method of the
* parent class.
*/
vfunc_finalize(): void;
/**
* the generic getter for all properties of this type. Should be
* overridden for every type with properties.
* @param property_id
* @param value
* @param pspec
*/
vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
/**
* Emits a "notify" signal for the property `property_name` on `object`.
*
* When possible, eg. when signaling a property change from within the class
* that registered the property, you should use g_object_notify_by_pspec()
* instead.
*
* Note that emission of the notify signal may be blocked with
* g_object_freeze_notify(). In this case, the signal emissions are queued
* and will be emitted (in reverse order) when g_object_thaw_notify() is
* called.
* @param pspec
*/
vfunc_notify(pspec: GObject.ParamSpec): void;
/**
* the generic setter for all properties of this type. Should be
* overridden for every type with properties. If implementations of
* `set_property` don't emit property change notification explicitly, this will
* be done implicitly by the type system. However, if the notify signal is
* emitted explicitly, the type system will not emit it a second time.
* @param property_id
* @param value
* @param pspec
*/
vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
disconnect(id: number): void;
set(properties: { [key: string]: any }): void;
block_signal_handler(id: number): any;
unblock_signal_handler(id: number): any;
stop_emission_by_name(detailedName: string): any;
}
module ViewPresentation {
// Signal callback interfaces
interface ChangePage {
(object: Gtk.ScrollType): void;
}
interface ExternalLink {
(object: GObject.Object): void;
}
interface Finished {
(): void;
}
// Constructor properties interface
interface ConstructorProps
extends Gtk.Widget.ConstructorProps,
Atk.ImplementorIface.ConstructorProps,
Gtk.Buildable.ConstructorProps {
current_page: number;
currentPage: number;
document: EvinceDocument.Document;
inverted_colors: boolean;
invertedColors: boolean;
rotation: number;
}
}
class ViewPresentation extends Gtk.Widget implements Atk.ImplementorIface, Gtk.Buildable {
static $gtype: GObject.GType<ViewPresentation>;
// Properties
get current_page(): number;
set current_page(val: number);
get currentPage(): number;
set currentPage(val: number);
set document(val: EvinceDocument.Document);
set inverted_colors(val: boolean);
set invertedColors(val: boolean);
get rotation(): number;
set rotation(val: number);
// Constructors
constructor(properties?: Partial<ViewPresentation.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](
document: EvinceDocument.Document,
current_page: number,
rotation: number,
inverted_colors: boolean,
): ViewPresentation;
// 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: 'change-page', callback: (_source: this, object: Gtk.ScrollType) => void): number;
connect_after(signal: 'change-page', callback: (_source: this, object: Gtk.ScrollType) => void): number;
emit(signal: 'change-page', object: Gtk.ScrollType): void;
connect(signal: 'external-link', callback: (_source: this, object: GObject.Object) => void): number;
connect_after(signal: 'external-link', callback: (_source: this, object: GObject.Object) => void): number;
emit(signal: 'external-link', object: GObject.Object): void;
connect(signal: 'finished', callback: (_source: this) => void): number;
connect_after(signal: 'finished', callback: (_source: this) => void): number;
emit(signal: 'finished'): void;
// Methods
get_current_page(): number;
get_rotation(): number;
next_page(): void;
previous_page(): void;
set_rotation(rotation: number): void;
// Inherited methods
/**
* Adds a child to `buildable`. `type` is an optional string
* describing how the child should be added.
* @param builder a #GtkBuilder
* @param child child to add
* @param type kind of child or %NULL
*/
add_child(builder: Gtk.Builder, child: GObject.Object, type?: string | null): void;
/**
* Constructs a child of `buildable` with the name `name`.
*
* #GtkBuilder calls this function if a “constructor” has been
* specified in the UI definition.
* @param builder #GtkBuilder used to construct this object
* @param name name of child to construct
* @returns the constructed child
*/
construct_child<T = GObject.Object>(builder: Gtk.Builder, name: string): T;
/**
* This is similar to gtk_buildable_parser_finished() but is
* called once for each custom tag handled by the `buildable`.
* @param builder a #GtkBuilder
* @param child child object or %NULL for non-child tags
* @param tagname the name of the tag
* @param data user data created in custom_tag_start
*/
custom_finished(
builder: Gtk.Builder,
child: GObject.Object | null,
tagname: string,
data?: any | null,
): void;
/**
* This is called at the end of each custom element handled by
* the buildable.
* @param builder #GtkBuilder used to construct this object
* @param child child object or %NULL for non-child tags
* @param tagname name of tag
* @param data user data that will be passed in to parser functions
*/
custom_tag_end(
builder: Gtk.Builder,
child: GObject.Object | null,
tagname: string,
data?: any | null,
): void;
/**
* This is called for each unknown element under `<child>`.
* @param builder a #GtkBuilder used to construct this object
* @param child child object or %NULL for non-child tags
* @param tagname name of tag
* @returns %TRUE if a object has a custom implementation, %FALSE if it doesn't.
*/
custom_tag_start(
builder: Gtk.Builder,
child: GObject.Object | null,
tagname: string,
): [boolean, GLib.MarkupParser, any];
/**
* Get the internal child called `childname` of the `buildable` object.
* @param builder a #GtkBuilder
* @param childname name of child
* @returns the internal child of the buildable object
*/
get_internal_child<T = GObject.Object>(builder: Gtk.Builder, childname: string): T;
/**
* Gets the name of the `buildable` object.
*
* #GtkBuilder sets the name based on the
* [GtkBuilder UI definition][BUILDER-UI]
* used to construct the `buildable`.
* @returns the name set with gtk_buildable_set_name()
*/
get_name(): string;
/**
* Called when the builder finishes the parsing of a
* [GtkBuilder UI definition][BUILDER-UI].
* Note that this will be called once for each time
* gtk_builder_add_from_file() or gtk_builder_add_from_string()
* is called on a builder.
* @param builder a #GtkBuilder
*/
parser_finished(builder: Gtk.Builder): void;
/**
* Sets the property name `name` to `value` on the `buildable` object.
* @param builder a #GtkBuilder
* @param name name of property
* @param value value of property
*/
set_buildable_property(builder: Gtk.Builder, name: string, value: GObject.Value | any): void;
/**
* Sets the name of the `buildable` object.
* @param name name to set
*/
set_name(name: string): void;
/**
* Adds a child to `buildable`. `type` is an optional string
* describing how the child should be added.
* @param builder a #GtkBuilder
* @param child child to add
* @param type kind of child or %NULL
*/
vfunc_add_child(builder: Gtk.Builder, child: GObject.Object, type?: string | null): void;
/**
* Constructs a child of `buildable` with the name `name`.
*
* #GtkBuilder calls this function if a “constructor” has been
* specified in the UI definition.
* @param builder #GtkBuilder used to construct this object
* @param name name of child to construct
*/
vfunc_construct_child<T = GObject.Object>(builder: Gtk.Builder, name: string): T;
/**
* This is similar to gtk_buildable_parser_finished() but is
* called once for each custom tag handled by the `buildable`.
* @param builder a #GtkBuilder
* @param child child object or %NULL for non-child tags
* @param tagname the name of the tag
* @param data user data created in custom_tag_start
*/
vfunc_custom_finished(
builder: Gtk.Builder,
child: GObject.Object | null,
tagname: string,
data?: any | null,
): void;
/**
* This is called at the end of each custom element handled by
* the buildable.
* @param builder #GtkBuilder used to construct this object
* @param child child object or %NULL for non-child tags
* @param tagname name of tag
* @param data user data that will be passed in to parser functions
*/
vfunc_custom_tag_end(
builder: Gtk.Builder,
child: GObject.Object | null,
tagname: string,
data?: any | null,
): void;
/**
* This is called for each unknown element under `<child>`.
* @param builder a #GtkBuilder used to construct this object
* @param child child object or %NULL for non-child tags
* @param tagname name of tag
*/
vfunc_custom_tag_start(
builder: Gtk.Builder,
child: GObject.Object | null,
tagname: string,
): [boolean, GLib.MarkupParser, any];
/**
* Get the internal child called `childname` of the `buildable` object.
* @param builder a #GtkBuilder
* @param childname name of child
*/
vfunc_get_internal_child<T = GObject.Object>(builder: Gtk.Builder, childname: string): T;
/**
* Gets the name of the `buildable` object.
*
* #GtkBuilder sets the name based on the
* [GtkBuilder UI definition][BUILDER-UI]
* used to construct the `buildable`.
*/
vfunc_get_name(): string;
/**
* Called when the builder finishes the parsing of a
* [GtkBuilder UI definition][BUILDER-UI].
* Note that this will be called once for each time
* gtk_builder_add_from_file() or gtk_builder_add_from_string()
* is called on a builder.
* @param builder a #GtkBuilder
*/
vfunc_parser_finished(builder: Gtk.Builder): void;
/**
* Sets the property name `name` to `value` on the `buildable` object.
* @param builder a #GtkBuilder
* @param name name of property
* @param value value of property
*/
vfunc_set_buildable_property(builder: Gtk.Builder, name: string, value: GObject.Value | any): void;
/**
* Sets the name of the `buildable` object.
* @param name name to set
*/
vfunc_set_name(name: string): void;
/**
* Creates a binding between `source_property` on `source` and `target_property`
* on `target`.
*
* Whenever the `source_property` is changed the `target_property` is
* updated using the same value. For instance:
*
*
* ```c
* g_object_bind_property (action, "active", widget, "sensitive", 0);
* ```
*
*
* Will result in the "sensitive" property of the widget #GObject instance to be
* updated with the same value of the "active" property of the action #GObject
* instance.
*
* If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
* if `target_property` on `target` changes then the `source_property` on `source`
* will be updated as well.
*
* The binding will automatically be removed when either the `source` or the
* `target` instances are finalized. To remove the binding without affecting the
* `source` and the `target` you can just call g_object_unref() on the returned
* #GBinding instance.
*
* Removing the binding by calling g_object_unref() on it must only be done if
* the binding, `source` and `target` are only used from a single thread and it
* is clear that both `source` and `target` outlive the binding. Especially it
* is not safe to rely on this if the binding, `source` or `target` can be
* finalized from different threads. Keep another reference to the binding and
* use g_binding_unbind() instead to be on the safe side.
*
* A #GObject can have multiple bindings.
* @param source_property the property on @source to bind
* @param target the target #GObject
* @param target_property the property on @target to bind
* @param flags flags to pass to #GBinding
* @returns the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero.
*/
bind_property(
source_property: string,
target: GObject.Object,
target_property: string,
flags: GObject.BindingFlags | null,
): GObject.Binding;
/**
* Complete version of g_object_bind_property().
*
* Creates a binding between `source_property` on `source` and `target_property`
* on `target,` allowing you to set the transformation functions to be used by
* the binding.
*
* If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
* if `target_property` on `target` changes then the `source_property` on `source`
* will be updated as well. The `transform_from` function is only used in case
* of bidirectional bindings, otherwise it will be ignored
*
* The binding will automatically be removed when either the `source` or the
* `target` instances are finalized. This will release the reference that is
* being held on the #GBinding instance; if you want to hold on to the
* #GBinding instance, you will need to hold a reference to it.
*
* To remove the binding, call g_binding_unbind().
*
* A #GObject can have multiple bindings.
*
* The same `user_data` parameter will be used for both `transform_to`
* and `transform_from` transformation functions; the `notify` function will
* be called once, when the binding is removed. If you need different data
* for each transformation function, please use
* g_object_bind_property_with_closures() instead.
* @param source_property the property on @source to bind
* @param target the target #GObject
* @param target_property the property on @target to bind
* @param flags flags to pass to #GBinding
* @param transform_to the transformation function from the @source to the @target, or %NULL to use the default
* @param transform_from the transformation function from the @target to the @source, or %NULL to use the default
* @param notify a function to call when disposing the binding, to free resources used by the transformation functions, or %NULL if not required
* @returns the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero.
*/
bind_property_full(
source_property: string,
target: GObject.Object,
target_property: string,
flags: GObject.BindingFlags | null,
transform_to?: GObject.BindingTransformFunc | null,
transform_from?: GObject.BindingTransformFunc | null,
notify?: GLib.DestroyNotify | null,
): GObject.Binding;
// Conflicted with GObject.Object.bind_property_full
bind_property_full(...args: never[]): any;
/**
* This function is intended for #GObject implementations to re-enforce
* a [floating][floating-ref] object reference. Doing this is seldom
* required: all #GInitiallyUnowneds are created with a floating reference
* which usually just needs to be sunken by calling g_object_ref_sink().
*/
force_floating(): void;
/**
* Increases the freeze count on `object`. If the freeze count is
* non-zero, the emission of "notify" signals on `object` is
* stopped. The signals are queued until the freeze count is decreased
* to zero. Duplicate notifications are squashed so that at most one
* #GObject::notify signal is emitted for each property modified while the
* object is frozen.
*
* This is necessary for accessors that modify multiple properties to prevent
* premature notification while the object is still being modified.
*/
freeze_notify(): void;
/**
* Gets a named field from the objects table of associations (see g_object_set_data()).
* @param key name of the key for that association
* @returns the data if found, or %NULL if no such data exists.
*/
get_data(key: string): any | null;
get_property(property_name: string): any;
/**
* This function gets back user data pointers stored via
* g_object_set_qdata().
* @param quark A #GQuark, naming the user data pointer
* @returns The user data pointer set, or %NULL
*/
get_qdata(quark: GLib.Quark): any | null;
/**
* Gets `n_properties` properties for an `object`.
* Obtained properties will be set to `values`. All properties must be valid.
* Warnings will be emitted and undefined behaviour may result if invalid
* properties are passed in.
* @param names the names of each property to get
* @param values the values of each property to get
*/
getv(names: string[], values: (GObject.Value | any)[]): void;
/**
* Checks whether `object` has a [floating][floating-ref] reference.
* @returns %TRUE if @object has a floating reference
*/
is_floating(): boolean;
/**
* Emits a "notify" signal for the property `property_name` on `object`.
*
* When possible, eg. when signaling a property change from within the class
* that registered the property, you should use g_object_notify_by_pspec()
* instead.
*
* Note that emission of the notify signal may be blocked with
* g_object_freeze_notify(). In this case, the signal emissions are queued
* and will be emitted (in reverse order) when g_object_thaw_notify() is
* called.
* @param property_name the name of a property installed on the class of @object.
*/
notify(property_name: string): void;
/**
* Emits a "notify" signal for the property specified by `pspec` on `object`.
*
* This function omits the property name lookup, hence it is faster than
* g_object_notify().
*
* One way to avoid using g_object_notify() from within the
* class that registered the properties, and using g_object_notify_by_pspec()
* instead, is to store the GParamSpec used with
* g_object_class_install_property() inside a static array, e.g.:
*
*
* ```c
* typedef enum
* {
* PROP_FOO = 1,
* PROP_LAST
* } MyObjectProperty;
*
* static GParamSpec *properties[PROP_LAST];
*
* static void
* my_object_class_init (MyObjectClass *klass)
* {
* properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
* 0, 100,
* 50,
* G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
* g_object_class_install_property (gobject_class,
* PROP_FOO,
* properties[PROP_FOO]);
* }
* ```
*
*
* and then notify a change on the "foo" property with:
*
*
* ```c
* g_object_notify_by_pspec (self, properties[PROP_FOO]);
* ```
*
* @param pspec the #GParamSpec of a property installed on the class of @object.
*/
notify_by_pspec(pspec: GObject.ParamSpec): void;
/**
* Increases the reference count of `object`.
*
* Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
* of `object` will be propagated to the return type (using the GCC typeof()
* extension), so any casting the caller needs to do on the return type must be
* explicit.
* @returns the same @object
*/
ref(): GObject.Object;
/**
* Increase the reference count of `object,` and possibly remove the
* [floating][floating-ref] reference, if `object` has a floating reference.
*
* In other words, if the object is floating, then this call "assumes
* ownership" of the floating reference, converting it to a normal
* reference by clearing the floating flag while leaving the reference
* count unchanged. If the object is not floating, then this call
* adds a new normal reference increasing the reference count by one.
*
* Since GLib 2.56, the type of `object` will be propagated to the return type
* under the same conditions as for g_object_ref().
* @returns @object
*/
ref_sink(): GObject.Object;
/**
* Releases all references to other objects. This can be used to break
* reference cycles.
*
* This function should only be called from object system implementations.
*/
run_dispose(): void;
/**
* Each object carries around a table of associations from
* strings to pointers. This function lets you set an association.
*
* If the object already had an association with that name,
* the old association will be destroyed.
*
* Internally, the `key` is converted to a #GQuark using g_quark_from_string().
* This means a copy of `key` is kept permanently (even after `object` has been
* finalized) — so it is recommended to only use a small, bounded set of values
* for `key` in your program, to avoid the #GQuark storage growing unbounded.
* @param key name of the key
* @param data data to associate with that key
*/
set_data(key: string, data?: any | null): void;
set_property(property_name: string, value: any): void;
/**
* Remove a specified datum from the object's data associations,
* without invoking the association's destroy handler.
* @param key name of the key
* @returns the data if found, or %NULL if no such data exists.
*/
steal_data(key: string): any | null;
/**
* This function gets back user data pointers stored via
* g_object_set_qdata() and removes the `data` from object
* without invoking its destroy() function (if any was
* set).
* Usually, calling this function is only required to update
* user data pointers with a destroy notifier, for example:
*
* ```c
* void
* object_add_to_user_list (GObject *object,
* const gchar *new_string)
* {
* // the quark, naming the object data
* GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
* // retrieve the old string list
* GList *list = g_object_steal_qdata (object, quark_string_list);
*
* // prepend new string
* list = g_list_prepend (list, g_strdup (new_string));
* // this changed 'list', so we need to set it again
* g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
* }
* static void
* free_string_list (gpointer data)
* {
* GList *node, *list = data;
*
* for (node = list; node; node = node->next)
* g_free (node->data);
* g_list_free (list);
* }
* ```
*
* Using g_object_get_qdata() in the above example, instead of
* g_object_steal_qdata() would have left the destroy function set,
* and thus the partial string list would have been freed upon
* g_object_set_qdata_full().
* @param quark A #GQuark, naming the user data pointer
* @returns The user data pointer set, or %NULL
*/
steal_qdata(quark: GLib.Quark): any | null;
/**
* Reverts the effect of a previous call to
* g_object_freeze_notify(). The freeze count is decreased on `object`
* and when it reaches zero, queued "notify" signals are emitted.
*
* Duplicate notifications for each property are squashed so that at most one
* #GObject::notify signal is emitted for each property, in the reverse order
* in which they have been queued.
*
* It is an error to call this function when the freeze count is zero.
*/
thaw_notify(): void;
/**
* Decreases the reference count of `object`. When its reference count
* drops to 0, the object is finalized (i.e. its memory is freed).
*
* If the pointer to the #GObject may be reused in future (for example, if it is
* an instance variable of another object), it is recommended to clear the
* pointer to %NULL rather than retain a dangling pointer to a potentially
* invalid #GObject instance. Use g_clear_object() for this.
*/
unref(): void;
/**
* This function essentially limits the life time of the `closure` to
* the life time of the object. That is, when the object is finalized,
* the `closure` is invalidated by calling g_closure_invalidate() on
* it, in order to prevent invocations of the closure with a finalized
* (nonexisting) object. Also, g_object_ref() and g_object_unref() are
* added as marshal guards to the `closure,` to ensure that an extra
* reference count is held on `object` during invocation of the
* `closure`. Usually, this function will be called on closures that
* use this `object` as closure data.
* @param closure #GClosure to watch
*/
watch_closure(closure: GObject.Closure): void;
/**
* the `constructed` function is called by g_object_new() as the
* final step of the object creation process. At the point of the call, all
* construction properties have been set on the object. The purpose of this
* call is to allow for object initialisation steps that can only be performed
* after construction properties have been set. `constructed` implementors
* should chain up to the `constructed` call of their parent class to allow it
* to complete its initialisation.
*/
vfunc_constructed(): void;
/**
* emits property change notification for a bunch
* of properties. Overriding `dispatch_properties_changed` should be rarely
* needed.
* @param n_pspecs
* @param pspecs
*/
vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
/**
* the `dispose` function is supposed to drop all references to other
* objects, but keep the instance otherwise intact, so that client method
* invocations still work. It may be run multiple times (due to reference
* loops). Before returning, `dispose` should chain up to the `dispose` method
* of the parent class.
*/
vfunc_dispose(): void;
/**
* instance finalization function, should finish the finalization of
* the instance begun in `dispose` and chain up to the `finalize` method of the
* parent class.
*/
vfunc_finalize(): void;
/**
* the generic getter for all properties of this type. Should be
* overridden for every type with properties.
* @param property_id
* @param value
* @param pspec
*/
vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
/**
* Emits a "notify" signal for the property `property_name` on `object`.
*
* When possible, eg. when signaling a property change from within the class
* that registered the property, you should use g_object_notify_by_pspec()
* instead.
*
* Note that emission of the notify signal may be blocked with
* g_object_freeze_notify(). In this case, the signal emissions are queued
* and will be emitted (in reverse order) when g_object_thaw_notify() is
* called.
* @param pspec
*/
vfunc_notify(pspec: GObject.ParamSpec): void;
/**
* the generic setter for all properties of this type. Should be
* overridden for every type with properties. If implementations of
* `set_property` don't emit property change notification explicitly, this will
* be done implicitly by the type system. However, if the notify signal is
* emitted explicitly, the type system will not emit it a second time.
* @param property_id
* @param value
* @param pspec
*/
vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
disconnect(id: number): void;
set(properties: { [key: string]: any }): void;
block_signal_handler(id: number): any;
unblock_signal_handler(id: number): any;
stop_emission_by_name(detailedName: string): any;
}
type DocumentModelClass = typeof DocumentModel;
type JobAnnotsClass = typeof JobAnnots;
type JobAttachmentsClass = typeof JobAttachments;
type JobClass = typeof Job;
type JobExportClass = typeof JobExport;
type JobFindClass = typeof JobFind;
type JobFontsClass = typeof JobFonts;
type JobLayersClass = typeof JobLayers;
type JobLinksClass = typeof JobLinks;
type JobLoadClass = typeof JobLoad;
type JobLoadFdClass = typeof JobLoadFd;
type JobLoadGFileClass = typeof JobLoadGFile;
type JobLoadStreamClass = typeof JobLoadStream;
type JobPageDataClass = typeof JobPageData;
type JobPrintClass = typeof JobPrint;
type JobRenderClass = typeof JobRender;
type JobSaveClass = typeof JobSave;
type JobThumbnailClass = typeof JobThumbnail;
type PrintOperationClass = typeof PrintOperation;
type ViewClass = typeof View;
type ViewPresentationClass = typeof ViewPresentation;
/**
* 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 EvinceView;
}
declare module 'gi://EvinceView' {
import EvinceView30 from 'gi://EvinceView?version=3.0';
export default EvinceView30;
}
// END
Reference in New Issue View Git Blame Copy Permalink