1934 lines
64 KiB
TypeScript
1934 lines
64 KiB
TypeScript
//****************************************************************
|
|
// (Partially) Generated by: ToTypeScriptD
|
|
// Website: http://github.com/ToTypeScriptD/ToTypeScriptD
|
|
// Version: 0.0.0.0
|
|
// Date: 12/31/2016 7:25:21 PM
|
|
//
|
|
// Assemblies:
|
|
// Xilium.CefGlue.dll
|
|
//
|
|
//****************************************************************
|
|
|
|
|
|
|
|
declare module Xilium.CefGlue {
|
|
|
|
export class CefAllowCertificateErrorCallback {
|
|
HasOneRef: boolean;
|
|
Dispose(): void;
|
|
Continue(allow: boolean): void;
|
|
}
|
|
|
|
export class CefApp {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefAuthCallback {
|
|
HasOneRef: boolean;
|
|
Dispose(): void;
|
|
Continue(username: string, password: string): void;
|
|
Cancel(): void;
|
|
}
|
|
|
|
export class CefBeforeDownloadCallback {
|
|
HasOneRef: boolean;
|
|
Dispose(): void;
|
|
Continue(downloadPath: string, showDialog: boolean): void;
|
|
}
|
|
|
|
export class CefBinaryValue {
|
|
HasOneRef: boolean;
|
|
IsValid: boolean;
|
|
IsOwned: boolean;
|
|
Size: number;
|
|
Dispose(): void;
|
|
static Create(data: any): Xilium.CefGlue.CefBinaryValue;
|
|
Copy(): Xilium.CefGlue.CefBinaryValue;
|
|
GetData(buffer: any, bufferSize: number, dataOffset: number): number;
|
|
ToArray(): any;
|
|
}
|
|
|
|
export class CefBrowser {
|
|
HasOneRef: boolean;
|
|
CanGoBack: boolean;
|
|
CanGoForward: boolean;
|
|
IsLoading: boolean;
|
|
Identifier: number;
|
|
IsPopup: boolean;
|
|
HasDocument: boolean;
|
|
FrameCount: number;
|
|
Dispose(): void;
|
|
GetHost(): Xilium.CefGlue.CefBrowserHost;
|
|
GoBack(): void;
|
|
GoForward(): void;
|
|
Reload(): void;
|
|
ReloadIgnoreCache(): void;
|
|
StopLoad(): void;
|
|
IsSame(that: Xilium.CefGlue.CefBrowser): boolean;
|
|
GetMainFrame(): Xilium.CefGlue.CefFrame;
|
|
GetFocusedFrame(): Xilium.CefGlue.CefFrame;
|
|
GetFrame(identifier: number): Xilium.CefGlue.CefFrame;
|
|
GetFrame(name: string): Xilium.CefGlue.CefFrame;
|
|
GetFrameIdentifiers(): number[];
|
|
GetFrameNames(): string[];
|
|
SendProcessMessage(target: Xilium.CefGlue.CefProcessId, message: Xilium.CefGlue.CefProcessMessage): boolean;
|
|
}
|
|
|
|
export class CefBrowserHost {
|
|
HasOneRef: boolean;
|
|
IsMouseCursorChangeDisabled: boolean;
|
|
IsWindowRenderingDisabled: boolean;
|
|
Dispose(): void;
|
|
static CreateBrowser(windowInfo: Xilium.CefGlue.CefWindowInfo, client: Xilium.CefGlue.CefClient, settings: Xilium.CefGlue.CefBrowserSettings, url: string, requestContext: Xilium.CefGlue.CefRequestContext): void;
|
|
static CreateBrowser(windowInfo: Xilium.CefGlue.CefWindowInfo, client: Xilium.CefGlue.CefClient, settings: Xilium.CefGlue.CefBrowserSettings, url: string): void;
|
|
//static CreateBrowser(windowInfo: Xilium.CefGlue.CefWindowInfo, client: Xilium.CefGlue.CefClient, settings: Xilium.CefGlue.CefBrowserSettings, url: System.Uri, requestContext: Xilium.CefGlue.CefRequestContext): void;
|
|
static CreateBrowser(windowInfo: Xilium.CefGlue.CefWindowInfo, client: Xilium.CefGlue.CefClient, settings: Xilium.CefGlue.CefBrowserSettings, url: any, requestContext: Xilium.CefGlue.CefRequestContext): void;
|
|
//static CreateBrowser(windowInfo: Xilium.CefGlue.CefWindowInfo, client: Xilium.CefGlue.CefClient, settings: Xilium.CefGlue.CefBrowserSettings, url: System.Uri): void;
|
|
static CreateBrowser(windowInfo: Xilium.CefGlue.CefWindowInfo, client: Xilium.CefGlue.CefClient, settings: Xilium.CefGlue.CefBrowserSettings, url: any): void;
|
|
static CreateBrowser(windowInfo: Xilium.CefGlue.CefWindowInfo, client: Xilium.CefGlue.CefClient, settings: Xilium.CefGlue.CefBrowserSettings, requestContext: Xilium.CefGlue.CefRequestContext): void;
|
|
static CreateBrowser(windowInfo: Xilium.CefGlue.CefWindowInfo, client: Xilium.CefGlue.CefClient, settings: Xilium.CefGlue.CefBrowserSettings): void;
|
|
static CreateBrowserSync(windowInfo: Xilium.CefGlue.CefWindowInfo, client: Xilium.CefGlue.CefClient, settings: Xilium.CefGlue.CefBrowserSettings, url: string, requestContext: Xilium.CefGlue.CefRequestContext): Xilium.CefGlue.CefBrowser;
|
|
static CreateBrowserSync(windowInfo: Xilium.CefGlue.CefWindowInfo, client: Xilium.CefGlue.CefClient, settings: Xilium.CefGlue.CefBrowserSettings, url: string): Xilium.CefGlue.CefBrowser;
|
|
//static CreateBrowserSync(windowInfo: Xilium.CefGlue.CefWindowInfo, client: Xilium.CefGlue.CefClient, settings: Xilium.CefGlue.CefBrowserSettings, url: System.Uri, requestContext: Xilium.CefGlue.CefRequestContext): Xilium.CefGlue.CefBrowser;
|
|
static CreateBrowserSync(windowInfo: Xilium.CefGlue.CefWindowInfo, client: Xilium.CefGlue.CefClient, settings: Xilium.CefGlue.CefBrowserSettings, url: any, requestContext: Xilium.CefGlue.CefRequestContext): Xilium.CefGlue.CefBrowser;
|
|
//static CreateBrowserSync(windowInfo: Xilium.CefGlue.CefWindowInfo, client: Xilium.CefGlue.CefClient, settings: Xilium.CefGlue.CefBrowserSettings, url: System.Uri): Xilium.CefGlue.CefBrowser;
|
|
static CreateBrowserSync(windowInfo: Xilium.CefGlue.CefWindowInfo, client: Xilium.CefGlue.CefClient, settings: Xilium.CefGlue.CefBrowserSettings, url: any): Xilium.CefGlue.CefBrowser;
|
|
static CreateBrowserSync(windowInfo: Xilium.CefGlue.CefWindowInfo, client: Xilium.CefGlue.CefClient, settings: Xilium.CefGlue.CefBrowserSettings, requestContext: Xilium.CefGlue.CefRequestContext): Xilium.CefGlue.CefBrowser;
|
|
static CreateBrowserSync(windowInfo: Xilium.CefGlue.CefWindowInfo, client: Xilium.CefGlue.CefClient, settings: Xilium.CefGlue.CefBrowserSettings): Xilium.CefGlue.CefBrowser;
|
|
GetBrowser(): Xilium.CefGlue.CefBrowser;
|
|
CloseBrowser(forceClose: boolean): void;
|
|
SetFocus(focus: boolean): void;
|
|
SetWindowVisibility(visible: boolean): void;
|
|
GetWindowHandle(): number;
|
|
GetOpenerWindowHandle(): number;
|
|
GetClient(): Xilium.CefGlue.CefClient;
|
|
GetRequestContext(): Xilium.CefGlue.CefRequestContext;
|
|
GetZoomLevel(): number;
|
|
SetZoomLevel(value: number): void;
|
|
RunFileDialog(mode: Xilium.CefGlue.CefFileDialogMode, title: string, defaultFilePath: string, acceptFilters: string[], selectedAcceptFilter: number, callback: Xilium.CefGlue.CefRunFileDialogCallback): void;
|
|
StartDownload(url: string): void;
|
|
Print(): void;
|
|
Find(identifier: number, searchText: string, forward: boolean, matchCase: boolean, findNext: boolean): void;
|
|
StopFinding(clearSelection: boolean): void;
|
|
ShowDevTools(windowInfo: Xilium.CefGlue.CefWindowInfo, client: Xilium.CefGlue.CefClient, browserSettings: Xilium.CefGlue.CefBrowserSettings, inspectElementAt: Xilium.CefGlue.CefPoint): void;
|
|
CloseDevTools(): void;
|
|
GetNavigationEntries(visitor: Xilium.CefGlue.CefNavigationEntryVisitor, currentOnly: boolean): void;
|
|
SetMouseCursorChangeDisabled(disabled: boolean): void;
|
|
ReplaceMisspelling(word: string): void;
|
|
AddWordToDictionary(word: string): void;
|
|
WasResized(): void;
|
|
WasHidden(hidden: boolean): void;
|
|
NotifyScreenInfoChanged(): void;
|
|
Invalidate(type: Xilium.CefGlue.CefPaintElementType): void;
|
|
SendKeyEvent(keyEvent: Xilium.CefGlue.CefKeyEvent): void;
|
|
SendMouseClickEvent(event: Xilium.CefGlue.CefMouseEvent, type: Xilium.CefGlue.CefMouseButtonType, mouseUp: boolean, clickCount: number): void;
|
|
SendMouseMoveEvent(event: Xilium.CefGlue.CefMouseEvent, mouseLeave: boolean): void;
|
|
SendMouseWheelEvent(event: Xilium.CefGlue.CefMouseEvent, deltaX: number, deltaY: number): void;
|
|
SendFocusEvent(setFocus: boolean): void;
|
|
SendCaptureLostEvent(): void;
|
|
NotifyMoveOrResizeStarted(): void;
|
|
GetNSTextInputContext(): number;
|
|
HandleKeyEventBeforeTextInputClient(keyEvent: number): void;
|
|
HandleKeyEventAfterTextInputClient(keyEvent: number): void;
|
|
DragTargetDragEnter(dragData: Xilium.CefGlue.CefDragData, mouseEvent: Xilium.CefGlue.CefMouseEvent, allowedOps: Xilium.CefGlue.CefDragOperationsMask): void;
|
|
DragTargetDragOver(mouseEvent: Xilium.CefGlue.CefMouseEvent, allowedOps: Xilium.CefGlue.CefDragOperationsMask): void;
|
|
DragTargetDragLeave(): void;
|
|
DragTargetDrop(mouseEvent: Xilium.CefGlue.CefMouseEvent): void;
|
|
DragSourceEndedAt(x: number, y: number, op: Xilium.CefGlue.CefDragOperationsMask): void;
|
|
DragSourceSystemDragEnded(): void;
|
|
}
|
|
|
|
export class CefBrowserProcessHandler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefBrowserSettings {
|
|
WindowlessFrameRate: number;
|
|
StandardFontFamily: string;
|
|
FixedFontFamily: string;
|
|
SerifFontFamily: string;
|
|
SansSerifFontFamily: string;
|
|
CursiveFontFamily: string;
|
|
FantasyFontFamily: string;
|
|
DefaultFontSize: number;
|
|
DefaultFixedFontSize: number;
|
|
MinimumFontSize: number;
|
|
MinimumLogicalFontSize: number;
|
|
DefaultEncoding: string;
|
|
RemoteFonts: Xilium.CefGlue.CefState;
|
|
JavaScript: Xilium.CefGlue.CefState;
|
|
JavaScriptOpenWindows: Xilium.CefGlue.CefState;
|
|
JavaScriptCloseWindows: Xilium.CefGlue.CefState;
|
|
JavaScriptAccessClipboard: Xilium.CefGlue.CefState;
|
|
JavaScriptDomPaste: Xilium.CefGlue.CefState;
|
|
CaretBrowsing: Xilium.CefGlue.CefState;
|
|
Java: Xilium.CefGlue.CefState;
|
|
Plugins: Xilium.CefGlue.CefState;
|
|
UniversalAccessFromFileUrls: Xilium.CefGlue.CefState;
|
|
FileAccessFromFileUrls: Xilium.CefGlue.CefState;
|
|
WebSecurity: Xilium.CefGlue.CefState;
|
|
ImageLoading: Xilium.CefGlue.CefState;
|
|
ImageShrinkStandaloneToFit: Xilium.CefGlue.CefState;
|
|
TextAreaResize: Xilium.CefGlue.CefState;
|
|
TabToLinks: Xilium.CefGlue.CefState;
|
|
LocalStorage: Xilium.CefGlue.CefState;
|
|
Databases: Xilium.CefGlue.CefState;
|
|
ApplicationCache: Xilium.CefGlue.CefState;
|
|
WebGL: Xilium.CefGlue.CefState;
|
|
BackgroundColor: Xilium.CefGlue.CefColor;
|
|
constructor();
|
|
}
|
|
|
|
export class CefCallback {
|
|
HasOneRef: boolean;
|
|
Dispose(): void;
|
|
Continue(): void;
|
|
Cancel(): void;
|
|
}
|
|
|
|
export class CefClient {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefColor {
|
|
A: number;
|
|
R: number;
|
|
G: number;
|
|
B: number;
|
|
constructor(argb: number);
|
|
constructor(alpha: number, red: number, green: number, blue: number);
|
|
ToArgb(): number;
|
|
}
|
|
|
|
enum CefColorModel {
|
|
Unknown = 0,
|
|
Gray = 1,
|
|
Color = 2,
|
|
Cmyk = 3,
|
|
Cmy = 4,
|
|
Kcmy = 5,
|
|
Cmy_K = 6,
|
|
Black = 7,
|
|
Grayscale = 8,
|
|
Rgb = 9,
|
|
Rgb16 = 10,
|
|
Rgba = 11,
|
|
ColorMode_Color = 12,
|
|
ColorMode_Monochrome = 13,
|
|
HP_Color_Color = 14,
|
|
HP_Color_Black = 15,
|
|
PrintoutMode_Normal = 16,
|
|
PrintoutMode_Normal_Gray = 17,
|
|
ProcessColorModel_Cmyk = 18,
|
|
ProcessColorModel_Greyscale = 19,
|
|
ProcessColorModel_Rgb = 20
|
|
}
|
|
|
|
export class CefCommandLine {
|
|
HasOneRef: boolean;
|
|
Global: Xilium.CefGlue.CefCommandLine;
|
|
IsValid: boolean;
|
|
IsReadOnly: boolean;
|
|
HasSwitches: boolean;
|
|
HasArguments: boolean;
|
|
Dispose(): void;
|
|
static Create(): Xilium.CefGlue.CefCommandLine;
|
|
Copy(): Xilium.CefGlue.CefCommandLine;
|
|
Reset(): void;
|
|
GetArgv(): string[];
|
|
ToString(): string;
|
|
GetProgram(): string;
|
|
SetProgram(value: string): void;
|
|
HasSwitch(name: string): boolean;
|
|
GetSwitchValue(name: string): string;
|
|
GetSwitches(): string[];
|
|
AppendSwitch(name: string): void;
|
|
AppendSwitch(name: string, value: string): void;
|
|
GetArguments(): string[];
|
|
AppendArgument(value: string): void;
|
|
PrependWrapper(wrapper: string): void;
|
|
PrependArgument(argument: string): void;
|
|
}
|
|
|
|
export class CefCompletionCallback {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
enum CefContextMenuEditStateFlags {
|
|
None = 0,
|
|
CanUndo = 1,
|
|
CanRedo = 2,
|
|
CanCut = 4,
|
|
CanCopy = 8,
|
|
CanPaste = 16,
|
|
CanDelete = 32,
|
|
CanSelectAll = 64,
|
|
CanTranslate = 128
|
|
}
|
|
|
|
export class CefContextMenuHandler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
enum CefContextMenuMediaStateFlags {
|
|
None = 0,
|
|
Error = 1,
|
|
Paused = 2,
|
|
Muted = 4,
|
|
Loop = 8,
|
|
CanSave = 16,
|
|
HasAudio = 32,
|
|
HasVideo = 64,
|
|
ControlRootElement = 128,
|
|
CanPrint = 256,
|
|
CanRotate = 512
|
|
}
|
|
|
|
enum CefContextMenuMediaType {
|
|
None = 0,
|
|
Image = 1,
|
|
Video = 2,
|
|
Audio = 3,
|
|
File = 4,
|
|
Plugin = 5
|
|
}
|
|
|
|
export class CefContextMenuParams {
|
|
HasOneRef: boolean;
|
|
X: number;
|
|
Y: number;
|
|
ContextMenuType: Xilium.CefGlue.CefContextMenuTypeFlags;
|
|
LinkUrl: string;
|
|
UnfilteredLinkUrl: string;
|
|
SourceUrl: string;
|
|
HasImageContents: boolean;
|
|
PageUrl: string;
|
|
FrameUrl: string;
|
|
FrameCharset: string;
|
|
MediaType: Xilium.CefGlue.CefContextMenuMediaType;
|
|
MediaState: Xilium.CefGlue.CefContextMenuMediaStateFlags;
|
|
SelectionText: string;
|
|
IsEditable: boolean;
|
|
IsSpellCheckEnabled: boolean;
|
|
EditState: Xilium.CefGlue.CefContextMenuEditStateFlags;
|
|
Dispose(): void;
|
|
GetMisspelledWord(): string;
|
|
GetMisspellingHash(): number;
|
|
GetDictionarySuggestions(): string[];
|
|
}
|
|
|
|
enum CefContextMenuTypeFlags {
|
|
None = 0,
|
|
Page = 1,
|
|
Frame = 2,
|
|
Link = 4,
|
|
Media = 8,
|
|
Selection = 16,
|
|
Editable = 32
|
|
}
|
|
|
|
enum CefContextSafetyImplementation {
|
|
Disabled = -1,
|
|
SafeDefault = 0,
|
|
SafeAlternate = 1
|
|
}
|
|
|
|
export class CefCookie {
|
|
Name: string;
|
|
Value: string;
|
|
Domain: string;
|
|
Path: string;
|
|
Secure: boolean;
|
|
HttpOnly: boolean;
|
|
Creation: Date;
|
|
LastAccess: Date;
|
|
//Expires?: Date;
|
|
Expires: Date;
|
|
constructor();
|
|
}
|
|
|
|
export class CefCookieManager {
|
|
HasOneRef: boolean;
|
|
Global: Xilium.CefGlue.CefCookieManager;
|
|
Dispose(): void;
|
|
static Create(path: string, persistSessionCookies: boolean): Xilium.CefGlue.CefCookieManager;
|
|
SetSupportedSchemes(schemes: string[]): void;
|
|
VisitAllCookies(visitor: Xilium.CefGlue.CefCookieVisitor): boolean;
|
|
VisitUrlCookies(url: string, includeHttpOnly: boolean, visitor: Xilium.CefGlue.CefCookieVisitor): boolean;
|
|
SetCookie(url: string, cookie: Xilium.CefGlue.CefCookie): boolean;
|
|
DeleteCookies(url: string, cookieName: string): boolean;
|
|
SetStoragePath(path: string, persistSessionCookies: boolean): boolean;
|
|
FlushStore(callback: Xilium.CefGlue.CefCompletionCallback): boolean;
|
|
}
|
|
|
|
export class CefCookieVisitor {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefCursorInfo {
|
|
HotSpot: Xilium.CefGlue.CefPoint;
|
|
ImageScaleFactor: number;
|
|
Size: Xilium.CefGlue.CefSize;
|
|
GetBuffer(): any;
|
|
}
|
|
|
|
enum CefCursorType {
|
|
Pointer = 0,
|
|
Cross = 1,
|
|
Hand = 2,
|
|
IBeam = 3,
|
|
Wait = 4,
|
|
Help = 5,
|
|
EastResize = 6,
|
|
NorthResize = 7,
|
|
NorthEastResize = 8,
|
|
NorthWestResize = 9,
|
|
SouthResize = 10,
|
|
SouthEastResize = 11,
|
|
SouthWestResize = 12,
|
|
WestResize = 13,
|
|
NorthSouthResize = 14,
|
|
EastWestResize = 15,
|
|
NorthEastSouthWestResize = 16,
|
|
NorthWestSouthEastResize = 17,
|
|
ColumnResize = 18,
|
|
RowResize = 19,
|
|
MiddlePanning = 20,
|
|
EastPanning = 21,
|
|
NorthPanning = 22,
|
|
NorthEastPanning = 23,
|
|
NorthWestPanning = 24,
|
|
SouthPanning = 25,
|
|
SouthEastPanning = 26,
|
|
SouthWestPanning = 27,
|
|
WestPanning = 28,
|
|
Move = 29,
|
|
VerticalText = 30,
|
|
Cell = 31,
|
|
ContextMenu = 32,
|
|
Alias = 33,
|
|
Progress = 34,
|
|
NoDrop = 35,
|
|
Copy = 36,
|
|
None = 37,
|
|
NotAllowed = 38,
|
|
ZoomIn = 39,
|
|
ZoomOut = 40,
|
|
Grab = 41,
|
|
Grabbing = 42,
|
|
Custom = 43
|
|
}
|
|
|
|
export class CefDialogHandler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefDictionaryValue {
|
|
HasOneRef: boolean;
|
|
IsValid: boolean;
|
|
IsOwned: boolean;
|
|
IsReadOnly: boolean;
|
|
Count: number;
|
|
Dispose(): void;
|
|
static Create(): Xilium.CefGlue.CefDictionaryValue;
|
|
Copy(excludeEmptyChildren: boolean): Xilium.CefGlue.CefDictionaryValue;
|
|
Clear(): boolean;
|
|
HasKey(key: string): boolean;
|
|
GetKeys(): string[];
|
|
Remove(key: string): boolean;
|
|
GetKeyType(key: string): Xilium.CefGlue.CefValueType;
|
|
GetBool(key: string): boolean;
|
|
GetInt(key: string): number;
|
|
GetDouble(key: string): number;
|
|
GetString(key: string): string;
|
|
GetBinary(key: string): Xilium.CefGlue.CefBinaryValue;
|
|
GetDictionary(key: string): Xilium.CefGlue.CefDictionaryValue;
|
|
GetList(key: string): Xilium.CefGlue.CefListValue;
|
|
SetNull(key: string): boolean;
|
|
SetBool(key: string, value: boolean): boolean;
|
|
SetInt(key: string, value: number): boolean;
|
|
SetDouble(key: string, value: number): boolean;
|
|
SetString(key: string, value: string): boolean;
|
|
SetBinary(key: string, value: Xilium.CefGlue.CefBinaryValue): boolean;
|
|
SetDictionary(key: string, value: Xilium.CefGlue.CefDictionaryValue): boolean;
|
|
SetList(key: string, value: Xilium.CefGlue.CefListValue): boolean;
|
|
}
|
|
|
|
export class CefDisplayHandler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefDomDocument {
|
|
HasOneRef: boolean;
|
|
DocumentType: Xilium.CefGlue.CefDomDocumentType;
|
|
Root: Xilium.CefGlue.CefDomNode;
|
|
Body: Xilium.CefGlue.CefDomNode;
|
|
Head: Xilium.CefGlue.CefDomNode;
|
|
Title: string;
|
|
FocusedNode: Xilium.CefGlue.CefDomNode;
|
|
HasSelection: boolean;
|
|
SelectionStartOffset: number;
|
|
GetSelectionEndOffset: number;
|
|
SelectionAsMarkup: string;
|
|
GetSelectionAsText: string;
|
|
BaseUrl: string;
|
|
Dispose(): void;
|
|
GetElementById(id: string): Xilium.CefGlue.CefDomNode;
|
|
GetCompleteUrl(partialUrl: string): string;
|
|
}
|
|
|
|
enum CefDomDocumentType {
|
|
Unknown = 0,
|
|
Html = 1,
|
|
Xhtml = 2,
|
|
Plugin = 3
|
|
}
|
|
|
|
export class CefDomEvent {
|
|
HasOneRef: boolean;
|
|
Dispose(): void;
|
|
}
|
|
|
|
enum CefDomEventCategory {
|
|
Unknown = 0,
|
|
UI = 1,
|
|
Mouse = 2,
|
|
Mutation = 4,
|
|
Keyboard = 8,
|
|
Text = 16,
|
|
Composition = 32,
|
|
Drag = 64,
|
|
Clipboard = 128,
|
|
Message = 256,
|
|
Wheel = 512,
|
|
BeforeTextInserted = 1024,
|
|
Overflow = 2048,
|
|
PageTransition = 4096,
|
|
PopState = 8192,
|
|
Progress = 16384,
|
|
XmlHttpRequestProgress = 32768
|
|
}
|
|
|
|
enum CefDomEventPhase {
|
|
Unknown = 0,
|
|
Capturing = 1,
|
|
AtTarget = 2,
|
|
Bubbling = 3
|
|
}
|
|
|
|
export class CefDomNode {
|
|
HasOneRef: boolean;
|
|
NodeType: Xilium.CefGlue.CefDomNodeType;
|
|
IsText: boolean;
|
|
IsElement: boolean;
|
|
IsEditable: boolean;
|
|
IsFormControlElement: boolean;
|
|
FormControlElementType: string;
|
|
Name: string;
|
|
Value: string;
|
|
Document: Xilium.CefGlue.CefDomDocument;
|
|
Parent: Xilium.CefGlue.CefDomNode;
|
|
PreviousSibling: Xilium.CefGlue.CefDomNode;
|
|
NextSibling: Xilium.CefGlue.CefDomNode;
|
|
HasChildren: boolean;
|
|
FirstChild: Xilium.CefGlue.CefDomNode;
|
|
LastChild: Xilium.CefGlue.CefDomNode;
|
|
ElementTagName: string;
|
|
HasAttributes: boolean;
|
|
InnerText: string;
|
|
Dispose(): void;
|
|
IsSame(that: Xilium.CefGlue.CefDomNode): boolean;
|
|
SetValue(value: string): boolean;
|
|
GetAsMarkup(): string;
|
|
HasAttribute(attrName: string): boolean;
|
|
GetAttribute(attrName: string): string;
|
|
GetAttributes(): string[];
|
|
SetAttribute(attrName: string, value: string): boolean;
|
|
}
|
|
|
|
enum CefDomNodeType {
|
|
Unsupported = 0,
|
|
Element = 1,
|
|
Attribute = 2,
|
|
Text = 3,
|
|
CDataSection = 4,
|
|
ProcessingInstruction = 5,
|
|
Comment = 6,
|
|
Document = 7,
|
|
DocumentType = 8,
|
|
DocumentFragment = 9
|
|
}
|
|
|
|
export class CefDomVisitor {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefDownloadHandler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefDownloadItem {
|
|
HasOneRef: boolean;
|
|
IsValid: boolean;
|
|
IsInProgress: boolean;
|
|
IsComplete: boolean;
|
|
IsCanceled: boolean;
|
|
CurrentSpeed: number;
|
|
PercentComplete: number;
|
|
TotalBytes: number;
|
|
ReceivedBytes: number;
|
|
StartTime: Date;
|
|
EndTime: Date;
|
|
FullPath: string;
|
|
Id: number;
|
|
Url: string;
|
|
OriginalUrl: string;
|
|
SuggestedFileName: string;
|
|
ContentDisposition: string;
|
|
MimeType: string;
|
|
Dispose(): void;
|
|
}
|
|
|
|
export class CefDownloadItemCallback {
|
|
HasOneRef: boolean;
|
|
Dispose(): void;
|
|
Cancel(): void;
|
|
Pause(): void;
|
|
Resume(): void;
|
|
}
|
|
|
|
export class CefDragData {
|
|
HasOneRef: boolean;
|
|
IsReadOnly: boolean;
|
|
IsLink: boolean;
|
|
IsFragment: boolean;
|
|
IsFile: boolean;
|
|
LinkUrl: string;
|
|
LinkTitle: string;
|
|
LinkMetadata: string;
|
|
FragmentText: string;
|
|
FragmentHtml: string;
|
|
FragmentBaseUrl: string;
|
|
FileName: string;
|
|
Dispose(): void;
|
|
static Create(): Xilium.CefGlue.CefDragData;
|
|
Clone(): Xilium.CefGlue.CefDragData;
|
|
GetFileContents(writer: Xilium.CefGlue.CefStreamWriter): number;
|
|
GetFileNames(): string[];
|
|
SetLinkURL(url: string): void;
|
|
SetLinkTitle(title: string): void;
|
|
SetLinkMetadata(data: string): void;
|
|
SetFragmentText(text: string): void;
|
|
SetFragmentHtml(html: string): void;
|
|
SetFragmentBaseURL(baseUrl: string): void;
|
|
ResetFileContents(): void;
|
|
AddFile(path: string, displayName: string): void;
|
|
}
|
|
|
|
export class CefDragHandler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
enum CefDragOperationsMask {
|
|
None = 0,
|
|
Copy = 1,
|
|
Link = 2,
|
|
Generic = 4,
|
|
Private = 8,
|
|
Move = 16,
|
|
Delete = 32,
|
|
Every = 4294967295
|
|
}
|
|
|
|
enum CefDuplexMode {
|
|
Unknown = -1,
|
|
Simplex = 0,
|
|
LongEdge = 1,
|
|
ShortEdge = 2
|
|
}
|
|
|
|
export class CefEndTracingCallback {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
enum CefErrorCode {
|
|
InsecureResponse = -501,
|
|
CacheMiss = -400,
|
|
ResponseHeadersTooBig = -325,
|
|
EmptyResponse = -324,
|
|
UnexpectedProxyAuth = -323,
|
|
MethodNotSupported = -322,
|
|
InvalidChunkedEncoding = -321,
|
|
InvalidResponse = -320,
|
|
UnsafePort = -312,
|
|
UnsafeRedirect = -311,
|
|
TooManyRedirects = -310,
|
|
UnknownUrlScheme = -302,
|
|
DisallowedUrlScheme = -301,
|
|
InvalidUrl = -300,
|
|
CertEnd = -208,
|
|
CertInvalid = -207,
|
|
CertRevoked = -206,
|
|
CertUnableToCheckRevocation = -205,
|
|
CertNoRevocationMechanism = -204,
|
|
CertContainsErrors = -203,
|
|
CertAuthorityInvalid = -202,
|
|
CertDateInvalid = -201,
|
|
CertCommonNameInvalid = -200,
|
|
SslRenegotiationRequested = -114,
|
|
SslVersionOrCipherMismatch = -113,
|
|
NoSslVersionsEnabled = -112,
|
|
TunnelConnectionFailed = -111,
|
|
SslClientAuthCertNeeded = -110,
|
|
AddressUnreachable = -109,
|
|
AddressInvalid = -108,
|
|
SslProtocolError = -107,
|
|
InternetDisconnected = -106,
|
|
NameNotResolved = -105,
|
|
ConnectionFailed = -104,
|
|
ConnectionAborted = -103,
|
|
ConnectionRefused = -102,
|
|
ConnectionReset = -101,
|
|
ConnectionClosed = -100,
|
|
NotImplemented = -11,
|
|
AccessDenied = -10,
|
|
Unexpected = -9,
|
|
FileTooBig = -8,
|
|
TimedOut = -7,
|
|
FileNotFound = -6,
|
|
InvalidHandle = -5,
|
|
InvalidArgument = -4,
|
|
Aborted = -3,
|
|
Failed = -2,
|
|
None = 0
|
|
}
|
|
|
|
enum CefEventFlags {
|
|
None = 0,
|
|
CapsLockOn = 1,
|
|
ShiftDown = 2,
|
|
ControlDown = 4,
|
|
AltDown = 8,
|
|
LeftMouseButton = 16,
|
|
MiddleMouseButton = 32,
|
|
RightMouseButton = 64,
|
|
CommandDown = 128,
|
|
NumLockOn = 256,
|
|
IsKeyPad = 512,
|
|
IsLeft = 1024,
|
|
IsRight = 2048
|
|
}
|
|
|
|
export class CefFileDialogCallback {
|
|
HasOneRef: boolean;
|
|
Dispose(): void;
|
|
Continue(selectedAcceptFilter: number, filePaths: string[]): void;
|
|
Cancel(): void;
|
|
}
|
|
|
|
enum CefFileDialogMode {
|
|
Open = 0,
|
|
OpenMultiple = 1,
|
|
OpenFolder = 2,
|
|
Save = 3,
|
|
TypeMask = 255,
|
|
OverwritePromptFlag = 16777216,
|
|
HideReadOnlyFlag = 33554432
|
|
}
|
|
|
|
export class CefFindHandler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefFocusHandler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
enum CefFocusSource {
|
|
Navigation = 0,
|
|
System = 1
|
|
}
|
|
|
|
export class CefFrame {
|
|
HasOneRef: boolean;
|
|
IsValid: boolean;
|
|
IsMain: boolean;
|
|
IsFocused: boolean;
|
|
Name: string;
|
|
Identifier: number;
|
|
Parent: Xilium.CefGlue.CefFrame;
|
|
Url: string;
|
|
Browser: Xilium.CefGlue.CefBrowser;
|
|
V8Context: Xilium.CefGlue.CefV8Context;
|
|
Dispose(): void;
|
|
Undo(): void;
|
|
Redo(): void;
|
|
Cut(): void;
|
|
Copy(): void;
|
|
Paste(): void;
|
|
Delete(): void;
|
|
SelectAll(): void;
|
|
ViewSource(): void;
|
|
GetSource(visitor: Xilium.CefGlue.CefStringVisitor): void;
|
|
GetText(visitor: Xilium.CefGlue.CefStringVisitor): void;
|
|
LoadRequest(request: Xilium.CefGlue.CefRequest): void;
|
|
LoadUrl(url: string): void;
|
|
LoadString(content: string, url: string): void;
|
|
ExecuteJavaScript(code: string, url: string, line: number): void;
|
|
VisitDom(visitor: Xilium.CefGlue.CefDomVisitor): void;
|
|
}
|
|
|
|
export class CefGeolocationCallback {
|
|
HasOneRef: boolean;
|
|
Dispose(): void;
|
|
Continue(allow: boolean): void;
|
|
}
|
|
|
|
export class CefGeolocationHandler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefGeoposition {
|
|
Latitude: number;
|
|
Longitude: number;
|
|
Altitude: number;
|
|
Accuracy: number;
|
|
AltitudeAccuracy: number;
|
|
Heading: number;
|
|
Speed: number;
|
|
Timestamp: Date;
|
|
ErrorCode: Xilium.CefGlue.CefGeopositionErrorCode;
|
|
ErrorMessage: string;
|
|
}
|
|
|
|
enum CefGeopositionErrorCode {
|
|
None = 0,
|
|
PermissionDenied = 1,
|
|
PositionUnavailable = 2,
|
|
Timeout = 3
|
|
}
|
|
|
|
export class CefGetGeolocationCallback {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefJSDialogCallback {
|
|
HasOneRef: boolean;
|
|
Dispose(): void;
|
|
Continue(success: boolean, userInput: string): void;
|
|
}
|
|
|
|
export class CefJSDialogHandler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
enum CefJSDialogType {
|
|
Alert = 0,
|
|
Confirm = 1,
|
|
Prompt = 2
|
|
}
|
|
|
|
export class CefKeyboardHandler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefKeyEvent {
|
|
EventType: Xilium.CefGlue.CefKeyEventType;
|
|
Modifiers: Xilium.CefGlue.CefEventFlags;
|
|
WindowsKeyCode: number;
|
|
NativeKeyCode: number;
|
|
IsSystemKey: boolean;
|
|
Character: number;
|
|
UnmodifiedCharacter: number;
|
|
FocusOnEditableField: boolean;
|
|
constructor();
|
|
}
|
|
|
|
enum CefKeyEventType {
|
|
RawKeyDown = 0,
|
|
KeyDown = 1,
|
|
KeyUp = 2,
|
|
Char = 3
|
|
}
|
|
|
|
export class CefLifeSpanHandler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefListValue {
|
|
HasOneRef: boolean;
|
|
IsValid: boolean;
|
|
IsOwned: boolean;
|
|
IsReadOnly: boolean;
|
|
Count: number;
|
|
Dispose(): void;
|
|
static Create(): Xilium.CefGlue.CefListValue;
|
|
Copy(): Xilium.CefGlue.CefListValue;
|
|
SetSize(size: number): boolean;
|
|
Clear(): boolean;
|
|
Remove(index: number): boolean;
|
|
GetValueType(index: number): Xilium.CefGlue.CefValueType;
|
|
GetBool(index: number): boolean;
|
|
GetInt(index: number): number;
|
|
GetDouble(index: number): number;
|
|
GetString(index: number): string;
|
|
GetBinary(index: number): Xilium.CefGlue.CefBinaryValue;
|
|
GetDictionary(index: number): Xilium.CefGlue.CefDictionaryValue;
|
|
GetList(index: number): Xilium.CefGlue.CefListValue;
|
|
SetNull(index: number): boolean;
|
|
SetBool(index: number, value: boolean): boolean;
|
|
SetInt(index: number, value: number): boolean;
|
|
SetDouble(index: number, value: number): boolean;
|
|
SetString(index: number, value: string): boolean;
|
|
SetBinary(index: number, value: Xilium.CefGlue.CefBinaryValue): boolean;
|
|
SetDictionary(index: number, value: Xilium.CefGlue.CefDictionaryValue): boolean;
|
|
SetList(index: number, value: Xilium.CefGlue.CefListValue): boolean;
|
|
}
|
|
|
|
export class CefLoadHandler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
enum CefLogSeverity {
|
|
Default = 0,
|
|
Verbose = 1,
|
|
Info = 2,
|
|
Warning = 3,
|
|
Error = 4,
|
|
ErrorReport = 5,
|
|
Disable = 99
|
|
}
|
|
|
|
export class CefMainArgs {
|
|
constructor(args: string[]);
|
|
}
|
|
|
|
enum CefMenuId {
|
|
Back = 100,
|
|
Forward = 101,
|
|
Reload = 102,
|
|
ReloadNoCache = 103,
|
|
StopLoad = 104,
|
|
Undo = 110,
|
|
Redo = 111,
|
|
Cut = 112,
|
|
Copy = 113,
|
|
Paste = 114,
|
|
Delete = 115,
|
|
SelectAll = 116,
|
|
Find = 130,
|
|
Print = 131,
|
|
ViewSource = 132,
|
|
SpellcheckSuggestion0 = 200,
|
|
SpellcheckSuggestion1 = 201,
|
|
SpellcheckSuggestion2 = 202,
|
|
SpellcheckSuggestion3 = 203,
|
|
SpellcheckSuggestion4 = 204,
|
|
SpellcheckSuggestionLast = 204,
|
|
NoSpellingSuggestions = 205,
|
|
AddToDictionary = 206,
|
|
UserFirst = 26500,
|
|
UserLast = 28500
|
|
}
|
|
|
|
enum CefMenuItemType {
|
|
None = 0,
|
|
Command = 1,
|
|
Check = 2,
|
|
Radio = 3,
|
|
Separator = 4,
|
|
SubMenu = 5
|
|
}
|
|
|
|
export class CefMenuModel {
|
|
HasOneRef: boolean;
|
|
Count: number;
|
|
Dispose(): void;
|
|
Clear(): boolean;
|
|
AddSeparator(): boolean;
|
|
AddItem(commandId: number, label: string): boolean;
|
|
AddCheckItem(commandId: number, label: string): boolean;
|
|
AddRadioItem(commandId: number, label: string, groupId: number): boolean;
|
|
AddSubMenu(commandId: number, label: string): Xilium.CefGlue.CefMenuModel;
|
|
InsertSeparatorAt(index: number): boolean;
|
|
InsertItemAt(index: number, commandId: number, label: string): boolean;
|
|
InsertCheckItemAt(index: number, commandId: number, label: string): boolean;
|
|
InsertRadioItemAt(index: number, commandId: number, label: string, groupId: number): boolean;
|
|
InsertSubMenuAt(index: number, commandId: number, label: string): Xilium.CefGlue.CefMenuModel;
|
|
Remove(commandId: number): boolean;
|
|
RemoveAt(index: number): boolean;
|
|
GetIndexOf(commandId: number): number;
|
|
GetCommandIdAt(index: number): number;
|
|
SetCommandIdAt(index: number, commandId: number): boolean;
|
|
GetLabel(commandId: number): string;
|
|
GetLabelAt(index: number): string;
|
|
SetLabel(commandId: number, label: string): boolean;
|
|
SetLabelAt(index: number, label: string): boolean;
|
|
GetItemType(commandId: number): Xilium.CefGlue.CefMenuItemType;
|
|
GetItemTypeAt(index: number): Xilium.CefGlue.CefMenuItemType;
|
|
GetGroupId(commandId: number): number;
|
|
GetGroupIdAt(index: number): number;
|
|
SetGroupId(commandId: number, groupId: number): boolean;
|
|
SetGroupIdAt(index: number, groupId: number): boolean;
|
|
GetSubMenu(commandId: number): Xilium.CefGlue.CefMenuModel;
|
|
GetSubMenuAt(index: number): Xilium.CefGlue.CefMenuModel;
|
|
IsVisible(commandId: number): boolean;
|
|
IsVisibleAt(index: number): boolean;
|
|
SetVisible(commandId: number, visible: boolean): boolean;
|
|
SetVisibleAt(index: number, visible: boolean): boolean;
|
|
IsEnabled(commandId: number): boolean;
|
|
IsEnabledAt(index: number): boolean;
|
|
SetEnabled(commandId: number, enabled: boolean): boolean;
|
|
SetEnabledAt(index: number, enabled: boolean): boolean;
|
|
IsChecked(commandId: number): boolean;
|
|
IsCheckedAt(index: number): boolean;
|
|
SetChecked(commandId: number, value: boolean): boolean;
|
|
SetCheckedAt(index: number, value: boolean): boolean;
|
|
HasAccelerator(commandId: number): boolean;
|
|
HasAcceleratorAt(index: number): boolean;
|
|
SetAccelerator(commandId: number, keyCode: number, shiftPressed: boolean, ctrlPressed: boolean, altPressed: boolean): boolean;
|
|
SetAcceleratorAt(index: number, keyCode: number, shiftPressed: boolean, ctrlPressed: boolean, altPressed: boolean): boolean;
|
|
RemoveAccelerator(commandId: number): boolean;
|
|
RemoveAcceleratorAt(index: number): boolean;
|
|
//GetAccelerator(commandId: number, keyCode: number &, shiftPressed: boolean &, ctrlPressed: boolean &, altPressed: boolean &): boolean;
|
|
GetAccelerator(commandId: number, keyCode: number, shiftPressed: boolean, ctrlPressed: boolean, altPressed: boolean): boolean;
|
|
//GetAcceleratorAt(index: number, keyCode: number &, shiftPressed: boolean &, ctrlPressed: boolean &, altPressed: boolean &): boolean;
|
|
GetAcceleratorAt(index: number, keyCode: number, shiftPressed: boolean, ctrlPressed: boolean, altPressed: boolean): boolean;
|
|
}
|
|
|
|
enum CefMouseButtonType {
|
|
Left = 0,
|
|
Middle = 1,
|
|
Right = 2
|
|
}
|
|
|
|
export class CefMouseEvent {
|
|
X: number;
|
|
Y: number;
|
|
Modifiers: Xilium.CefGlue.CefEventFlags;
|
|
constructor(x: number, y: number, modifiers: Xilium.CefGlue.CefEventFlags);
|
|
}
|
|
|
|
export class CefNavigationEntry {
|
|
HasOneRef: boolean;
|
|
IsValid: boolean;
|
|
Url: string;
|
|
GetDisplayUrl: string;
|
|
OriginalUrl: string;
|
|
Title: string;
|
|
TransitionType: Xilium.CefGlue.CefTransitionType;
|
|
HasPostData: boolean;
|
|
FrameName: string;
|
|
CompletionTime: Date;
|
|
HttpStatusCode: number;
|
|
Dispose(): void;
|
|
}
|
|
|
|
export class CefNavigationEntryVisitor {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
enum CefNavigationType {
|
|
LinkClicked = 0,
|
|
FormSubmitted = 1,
|
|
BackForwarD = 2,
|
|
Reload = 3,
|
|
FormResubmitted = 4,
|
|
Other = 5
|
|
}
|
|
|
|
export class CefPageRange {
|
|
From: number;
|
|
To: number;
|
|
constructor(from: number, to: number);
|
|
}
|
|
|
|
enum CefPaintElementType {
|
|
View = 0,
|
|
Popup = 1
|
|
}
|
|
|
|
enum CefPathKey {
|
|
Current = 0,
|
|
DirExe = 1,
|
|
DirModule = 2,
|
|
DirTemp = 3,
|
|
FileExe = 4,
|
|
FileModule = 5
|
|
}
|
|
|
|
export class CefPoint {
|
|
X: number;
|
|
Y: number;
|
|
constructor(x: number, y: number);
|
|
}
|
|
|
|
export class CefPopupFeatures {
|
|
//X?: number;
|
|
X: number;
|
|
//Y?: number;
|
|
Y: number;
|
|
//Width?: number;
|
|
Width: number;
|
|
//Height?: number;
|
|
Height: number;
|
|
MenuBarVisible: boolean;
|
|
StatusBarVisible: boolean;
|
|
ToolBarVisible: boolean;
|
|
LocationBarVisible: boolean;
|
|
ScrollbarsVisible: boolean;
|
|
Resizable: boolean;
|
|
Fullscreen: boolean;
|
|
Dialog: boolean;
|
|
AdditionalFeatures: string[];
|
|
}
|
|
|
|
export class CefPostData {
|
|
HasOneRef: boolean;
|
|
IsReadOnly: boolean;
|
|
Count: number;
|
|
Dispose(): void;
|
|
static Create(): Xilium.CefGlue.CefPostData;
|
|
GetElements(): Xilium.CefGlue.CefPostDataElement[];
|
|
Remove(element: Xilium.CefGlue.CefPostDataElement): boolean;
|
|
Add(element: Xilium.CefGlue.CefPostDataElement): boolean;
|
|
RemoveAll(): void;
|
|
}
|
|
|
|
export class CefPostDataElement {
|
|
HasOneRef: boolean;
|
|
IsReadOnly: boolean;
|
|
ElementType: Xilium.CefGlue.CefPostDataElementType;
|
|
BytesCount: number;
|
|
Dispose(): void;
|
|
static Create(): Xilium.CefGlue.CefPostDataElement;
|
|
SetToEmpty(): void;
|
|
SetToFile(fileName: string): void;
|
|
SetToBytes(bytes: any): void;
|
|
GetFile(): string;
|
|
GetBytes(): any;
|
|
}
|
|
|
|
enum CefPostDataElementType {
|
|
Empty = 0,
|
|
Bytes = 1,
|
|
File = 2
|
|
}
|
|
|
|
export class CefPrintDialogCallback {
|
|
HasOneRef: boolean;
|
|
Dispose(): void;
|
|
Continue(settings: Xilium.CefGlue.CefPrintSettings): void;
|
|
Cancel(): void;
|
|
}
|
|
|
|
export class CefPrintHandler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefPrintJobCallback {
|
|
HasOneRef: boolean;
|
|
Dispose(): void;
|
|
Continue(): void;
|
|
}
|
|
|
|
export class CefPrintSettings {
|
|
HasOneRef: boolean;
|
|
IsValid: boolean;
|
|
IsReadOnly: boolean;
|
|
DeviceName: string;
|
|
IsSelectionOnly: boolean;
|
|
WillCollate: boolean;
|
|
Dispose(): void;
|
|
static Create(): Xilium.CefGlue.CefPrintSettings;
|
|
Copy(): Xilium.CefGlue.CefPrintSettings;
|
|
SetOrientation(landscape: boolean): void;
|
|
IsLandscape(): boolean;
|
|
SetPrinterPrintableArea(physicalSizeDeviceUnits: Xilium.CefGlue.CefSize, printableAreaDeviceUnits: Xilium.CefGlue.CefRectangle, landscapeNeedsFlip: boolean): void;
|
|
SetDeviceName(name: string): void;
|
|
SetDpi(dpi: number): void;
|
|
GetDpi(): number;
|
|
SetPageRanges(ranges: Xilium.CefGlue.CefPageRange[]): void;
|
|
GetPageRangesCount(): number;
|
|
GetPageRanges(): Xilium.CefGlue.CefPageRange[];
|
|
SetSelectionOnly(selectionOnly: boolean): void;
|
|
SetCollate(collate: boolean): void;
|
|
SetColorModel(colorModel: Xilium.CefGlue.CefColorModel): void;
|
|
GetColorModel(): Xilium.CefGlue.CefColorModel;
|
|
SetCopies(copies: number): void;
|
|
GetCopies(): number;
|
|
SetDuplexMode(mode: Xilium.CefGlue.CefDuplexMode): void;
|
|
GetDuplexMode(): Xilium.CefGlue.CefDuplexMode;
|
|
}
|
|
|
|
enum CefProcessId {
|
|
Browser = 0,
|
|
Renderer = 1
|
|
}
|
|
|
|
export class CefProcessMessage {
|
|
HasOneRef: boolean;
|
|
IsValid: boolean;
|
|
IsReadOnly: boolean;
|
|
Name: string;
|
|
Arguments_: Xilium.CefGlue.CefListValue;
|
|
Dispose(): void;
|
|
static Create(name: string): Xilium.CefGlue.CefProcessMessage;
|
|
Copy(): Xilium.CefGlue.CefProcessMessage;
|
|
}
|
|
|
|
export class CefQuotaCallback {
|
|
HasOneRef: boolean;
|
|
Dispose(): void;
|
|
Continue(allow: boolean): void;
|
|
Cancel(): void;
|
|
}
|
|
|
|
export class CefReadHandler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefRectangle {
|
|
X: number;
|
|
Y: number;
|
|
Width: number;
|
|
Height: number;
|
|
constructor(x: number, y: number, width: number, height: number);
|
|
}
|
|
|
|
export class CefRenderHandler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefRenderProcessHandler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefRequest {
|
|
HasOneRef: boolean;
|
|
IsReadOnly: boolean;
|
|
Url: string;
|
|
Method: string;
|
|
PostData: Xilium.CefGlue.CefPostData;
|
|
Options: Xilium.CefGlue.CefUrlRequestOptions;
|
|
FirstPartyForCookies: string;
|
|
ResourceType: Xilium.CefGlue.CefResourceType;
|
|
TransitionType: Xilium.CefGlue.CefTransitionType;
|
|
Dispose(): void;
|
|
static Create(): Xilium.CefGlue.CefRequest;
|
|
//GetHeaderMap(): System.Collections.Specialized.NameValueCollection;
|
|
GetHeaderMap(): any;
|
|
//SetHeaderMap(headers: System.Collections.Specialized.NameValueCollection): void;
|
|
SetHeaderMap(headers: any): void;
|
|
Set(url: string, method: string, postData: Xilium.CefGlue.CefPostData, headers: any): void;
|
|
//Set(url: string, method: string, postData: Xilium.CefGlue.CefPostData, headers: System.Collections.Specialized.NameValueCollection): void;
|
|
}
|
|
|
|
export class CefRequestContext {
|
|
HasOneRef: boolean;
|
|
IsGlobal: boolean;
|
|
Dispose(): void;
|
|
static GetGlobalContext(): Xilium.CefGlue.CefRequestContext;
|
|
static CreateContext(handler: Xilium.CefGlue.CefRequestContextHandler): Xilium.CefGlue.CefRequestContext;
|
|
IsSame(other: Xilium.CefGlue.CefRequestContext): boolean;
|
|
GetHandler(): Xilium.CefGlue.CefRequestContextHandler;
|
|
}
|
|
|
|
export class CefRequestContextHandler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefRequestHandler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefResourceBundleHandler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefResourceHandler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
enum CefResourceType {
|
|
MainFrame = 0,
|
|
SubFrame = 1,
|
|
Stylesheet = 2,
|
|
Script = 3,
|
|
Image = 4,
|
|
FontResource = 5,
|
|
SubResource = 6,
|
|
Object = 7,
|
|
Media = 8,
|
|
Worker = 9,
|
|
SharedWorker = 10,
|
|
Prefetch = 11,
|
|
Favicon = 12,
|
|
Xhr = 13,
|
|
Ping = 14,
|
|
ServiceWorker = 15
|
|
}
|
|
|
|
export class CefResponse {
|
|
HasOneRef: boolean;
|
|
IsReadOnly: boolean;
|
|
Status: number;
|
|
StatusText: string;
|
|
MimeType: string;
|
|
Dispose(): void;
|
|
static Create(): Xilium.CefGlue.CefResponse;
|
|
GetHeader(name: string): string;
|
|
//GetHeaderMap(): System.Collections.Specialized.NameValueCollection;
|
|
GetHeaderMap(): any;
|
|
//SetHeaderMap(headers: System.Collections.Specialized.NameValueCollection): void;
|
|
SetHeaderMap(headers: any): void;
|
|
}
|
|
|
|
export class CefRunFileDialogCallback {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefRuntime {
|
|
Platform: Xilium.CefGlue.CefRuntimePlatform;
|
|
static Load(): void;
|
|
static Load(path: string): void;
|
|
static ExecuteProcess(args: Xilium.CefGlue.CefMainArgs, application: Xilium.CefGlue.CefApp, windowsSandboxInfo: number): number;
|
|
static ExecuteProcess(args: Xilium.CefGlue.CefMainArgs, application: Xilium.CefGlue.CefApp): number;
|
|
static Initialize(args: Xilium.CefGlue.CefMainArgs, settings: Xilium.CefGlue.CefSettings, application: Xilium.CefGlue.CefApp, windowsSandboxInfo: number): void;
|
|
static Initialize(args: Xilium.CefGlue.CefMainArgs, settings: Xilium.CefGlue.CefSettings, application: Xilium.CefGlue.CefApp): void;
|
|
static Shutdown(): void;
|
|
static DoMessageLoopWork(): void;
|
|
static RunMessageLoop(): void;
|
|
static QuitMessageLoop(): void;
|
|
static SetOSModalLoop(osModalLoop: boolean): void;
|
|
static CurrentlyOn(threadId: Xilium.CefGlue.CefThreadId): boolean;
|
|
static PostTask(threadId: Xilium.CefGlue.CefThreadId, task: Xilium.CefGlue.CefTask): boolean;
|
|
static PostTask(threadId: Xilium.CefGlue.CefThreadId, task: Xilium.CefGlue.CefTask, delay: number): boolean;
|
|
static GetGeolocation(callback: Xilium.CefGlue.CefGetGeolocationCallback): boolean;
|
|
static AddCrossOriginWhitelistEntry(sourceOrigin: string, targetProtocol: string, targetDomain: string, allowTargetSubdomains: boolean): boolean;
|
|
static RemoveCrossOriginWhitelistEntry(sourceOrigin: string, targetProtocol: string, targetDomain: string, allowTargetSubdomains: boolean): boolean;
|
|
static ClearCrossOriginWhitelist(): boolean;
|
|
static RegisterSchemeHandlerFactory(schemeName: string, domainName: string, factory: Xilium.CefGlue.CefSchemeHandlerFactory): boolean;
|
|
static ClearSchemeHandlerFactories(): boolean;
|
|
static RegisterExtension(extensionName: string, javascriptCode: string, handler: Xilium.CefGlue.CefV8Handler): boolean;
|
|
static VisitWebPluginInfo(visitor: Xilium.CefGlue.CefWebPluginInfoVisitor): void;
|
|
static RefreshWebPlugins(): void;
|
|
static AddWebPluginPath(path: string): void;
|
|
static AddWebPluginDirectory(directory: string): void;
|
|
static RemoveWebPluginPath(path: string): void;
|
|
static UnregisterInternalWebPlugin(path: string): void;
|
|
static ForceWebPluginShutdown(path: string): void;
|
|
static RegisterWebPluginCrash(path: string): void;
|
|
static IsWebPluginUnstable(path: string, callback: Xilium.CefGlue.CefWebPluginUnstableCallback): void;
|
|
static GetPath(pathKey: Xilium.CefGlue.CefPathKey): string;
|
|
static LaunchProcess(commandLine: Xilium.CefGlue.CefCommandLine): boolean;
|
|
}
|
|
|
|
export class CefRuntimeException {
|
|
constructor(message: string);
|
|
}
|
|
|
|
enum CefRuntimePlatform {
|
|
Windows = 0,
|
|
Linux = 1,
|
|
MacOSX = 2
|
|
}
|
|
|
|
export class CefSchemeHandlerFactory {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefSchemeRegistrar {
|
|
HasOneRef: boolean;
|
|
Dispose(): void;
|
|
AddCustomScheme(schemeName: string, standard: boolean, local: boolean, displayIsolated: boolean): boolean;
|
|
}
|
|
|
|
export class CefScreenInfo {
|
|
DeviceScaleFactor: number;
|
|
Depth: number;
|
|
DepthPerComponent: number;
|
|
IsMonochrome: boolean;
|
|
Rectangle: Xilium.CefGlue.CefRectangle;
|
|
AvailableRectangle: Xilium.CefGlue.CefRectangle;
|
|
}
|
|
|
|
export class CefSettings {
|
|
SingleProcess: boolean;
|
|
NoSandbox: boolean;
|
|
BrowserSubprocessPath: string;
|
|
MultiThreadedMessageLoop: boolean;
|
|
WindowlessRenderingEnabled: boolean;
|
|
CommandLineArgsDisabled: boolean;
|
|
CachePath: string;
|
|
PersistSessionCookies: boolean;
|
|
UserAgent: string;
|
|
ProductVersion: string;
|
|
Locale: string;
|
|
LogFile: string;
|
|
LogSeverity: Xilium.CefGlue.CefLogSeverity;
|
|
JavaScriptFlags: string;
|
|
ResourcesDirPath: string;
|
|
LocalesDirPath: string;
|
|
PackLoadingDisabled: boolean;
|
|
RemoteDebuggingPort: number;
|
|
UncaughtExceptionStackSize: number;
|
|
ContextSafetyImplementation: Xilium.CefGlue.CefContextSafetyImplementation;
|
|
IgnoreCertificateErrors: boolean;
|
|
BackgroundColor: Xilium.CefGlue.CefColor;
|
|
constructor();
|
|
}
|
|
|
|
export class CefSize {
|
|
Width: number;
|
|
Height: number;
|
|
constructor(width: number, height: number);
|
|
}
|
|
|
|
export class CefSslCertPrincipal {
|
|
HasOneRef: boolean;
|
|
DisplayName: string;
|
|
CommonName: string;
|
|
LocalityName: string;
|
|
StateOrProvinceName: string;
|
|
CountryName: string;
|
|
StreetAddresses: string[];
|
|
OrganizationNames: string[];
|
|
OrganizationUnitNames: string[];
|
|
DomainComponents: string[];
|
|
Dispose(): void;
|
|
}
|
|
|
|
export class CefSslInfo {
|
|
HasOneRef: boolean;
|
|
Subject: Xilium.CefGlue.CefSslCertPrincipal;
|
|
Issuer: Xilium.CefGlue.CefSslCertPrincipal;
|
|
SerialNumber: Xilium.CefGlue.CefBinaryValue;
|
|
ValidStart: Date;
|
|
ValidExpiry: Date;
|
|
DerEncoded: Xilium.CefGlue.CefBinaryValue;
|
|
PemEncoded: Xilium.CefGlue.CefBinaryValue;
|
|
Dispose(): void;
|
|
}
|
|
|
|
enum CefState {
|
|
Default = 0,
|
|
Enabled = 1,
|
|
Disabled = 2
|
|
}
|
|
|
|
enum CefStorageType {
|
|
Local = 0,
|
|
Session = 1
|
|
}
|
|
|
|
export class CefStreamReader {
|
|
HasOneRef: boolean;
|
|
Dispose(): void;
|
|
static Create(fileName: string): Xilium.CefGlue.CefStreamReader;
|
|
//static Create(data: void*, size: number): Xilium.CefGlue.CefStreamReader;
|
|
static Create(data: void, size: number): Xilium.CefGlue.CefStreamReader;
|
|
static Create(handler: Xilium.CefGlue.CefReadHandler): Xilium.CefGlue.CefStreamReader;
|
|
Read(buffer: any, offset: number, length: number): number;
|
|
//Seek(offset: number, whence: System.IO.SeekOrigin): boolean;
|
|
Seek(offset: number, whence: any): boolean;
|
|
Tell(): number;
|
|
Eof(): boolean;
|
|
MayBlock(): boolean;
|
|
}
|
|
|
|
export class CefStreamWriter {
|
|
HasOneRef: boolean;
|
|
Dispose(): void;
|
|
static Create(fileName: string): Xilium.CefGlue.CefStreamWriter;
|
|
static Create(handler: Xilium.CefGlue.CefWriteHandler): Xilium.CefGlue.CefStreamWriter;
|
|
Write(buffer: any, offset: number, length: number): number;
|
|
//Seek(offset: number, whence: System.IO.SeekOrigin): boolean;
|
|
Seek(offset: number, whence: any): boolean;
|
|
Tell(): number;
|
|
Flush(): boolean;
|
|
MayBlock(): boolean;
|
|
}
|
|
|
|
export class CefStringVisitor {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefTask {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefTaskRunner {
|
|
HasOneRef: boolean;
|
|
BelongsToCurrentThread: boolean;
|
|
Dispose(): void;
|
|
static GetForCurrentThread(): Xilium.CefGlue.CefTaskRunner;
|
|
static GetForThread(threadId: Xilium.CefGlue.CefThreadId): Xilium.CefGlue.CefTaskRunner;
|
|
IsSame(that: Xilium.CefGlue.CefTaskRunner): boolean;
|
|
BelongsToThread(threadId: Xilium.CefGlue.CefThreadId): boolean;
|
|
PostTask(task: Xilium.CefGlue.CefTask): boolean;
|
|
PostDelayedTask(task: Xilium.CefGlue.CefTask, delay: number): boolean;
|
|
}
|
|
|
|
enum CefTerminationStatus {
|
|
Termination = 0,
|
|
WasKilled = 1,
|
|
ProcessCrashed = 2
|
|
}
|
|
|
|
enum CefThreadId {
|
|
UI = 0,
|
|
DB = 1,
|
|
File = 2,
|
|
FileUserBlocking = 3,
|
|
ProcessLauncher = 4,
|
|
Cache = 5,
|
|
IO = 6,
|
|
Renderer = 7
|
|
}
|
|
|
|
enum CefTransitionType {
|
|
Link = 0,
|
|
Explicit = 1,
|
|
AutoSubframe = 3,
|
|
ManualSubframe = 4,
|
|
FormSubmit = 7,
|
|
Reload = 8,
|
|
SourceMask = 255,
|
|
BlockedFlag = 8388608,
|
|
ForwardBackFlag = 16777216,
|
|
ChainStartFlag = 268435456,
|
|
ChainEndFlag = 536870912,
|
|
ClientRedirectFlag = 1073741824,
|
|
ServerRedirectFlag = 2147483648,
|
|
IsRedirectMask = 3221225472,
|
|
QualifierMask = 4294967040
|
|
}
|
|
|
|
enum CefUriUnescapeRules {
|
|
None = 0,
|
|
Normal = 1,
|
|
Spaces = 2,
|
|
UrlSpecialChars = 4,
|
|
ControlChars = 8,
|
|
ReplacePlusWithSpace = 16
|
|
}
|
|
|
|
export class CefUrlRequest {
|
|
HasOneRef: boolean;
|
|
RequestStatus: Xilium.CefGlue.CefUrlRequestStatus;
|
|
RequestError: Xilium.CefGlue.CefErrorCode;
|
|
Dispose(): void;
|
|
static Create(request: Xilium.CefGlue.CefRequest, client: Xilium.CefGlue.CefUrlRequestClient): Xilium.CefGlue.CefUrlRequest;
|
|
GetRequest(): Xilium.CefGlue.CefRequest;
|
|
GetClient(): Xilium.CefGlue.CefUrlRequestClient;
|
|
GetResponse(): Xilium.CefGlue.CefResponse;
|
|
Cancel(): void;
|
|
}
|
|
|
|
export class CefUrlRequestClient {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
enum CefUrlRequestOptions {
|
|
None = 0,
|
|
SkipCache = 1,
|
|
AllowCachedCredentials = 2,
|
|
ReportUploadProgress = 8,
|
|
ReportRawHeaders = 32,
|
|
NoDownloadData = 64,
|
|
NoRetryOn5XX = 128
|
|
}
|
|
|
|
enum CefUrlRequestStatus {
|
|
Unknown = 0,
|
|
Success = 1,
|
|
IOPending = 2,
|
|
Canceled = 3,
|
|
Failed = 4
|
|
}
|
|
|
|
export class CefUserData {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
enum CefV8AccessControl {
|
|
Default = 0,
|
|
AllCanRead = 1,
|
|
AllCanWrite = 2,
|
|
ProhibitsOverwriting = 4
|
|
}
|
|
|
|
export class CefV8Accessor {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefV8Context {
|
|
HasOneRef: boolean;
|
|
InContext: boolean;
|
|
IsValid: boolean;
|
|
Dispose(): void;
|
|
static GetCurrentContext(): Xilium.CefGlue.CefV8Context;
|
|
static GetEnteredContext(): Xilium.CefGlue.CefV8Context;
|
|
GetTaskRunner(): Xilium.CefGlue.CefTaskRunner;
|
|
GetBrowser(): Xilium.CefGlue.CefBrowser;
|
|
GetFrame(): Xilium.CefGlue.CefFrame;
|
|
GetGlobal(): Xilium.CefGlue.CefV8Value;
|
|
Enter(): boolean;
|
|
Exit(): boolean;
|
|
IsSame(that: Xilium.CefGlue.CefV8Context): boolean;
|
|
//TryEval(code: string, returnValue: Xilium.CefGlue.CefV8Value&, exception: Xilium.CefGlue.CefV8Exception&): boolean;
|
|
TryEval(code: string, returnValue: Xilium.CefGlue.CefV8Value, exception: Xilium.CefGlue.CefV8Exception): boolean;
|
|
}
|
|
|
|
export class CefV8Exception {
|
|
HasOneRef: boolean;
|
|
Message: string;
|
|
SourceLine: string;
|
|
ScriptResourceName: string;
|
|
LineNumber: number;
|
|
StartPosition: number;
|
|
EndPosition: number;
|
|
StartColumn: number;
|
|
EndColumn: number;
|
|
Dispose(): void;
|
|
}
|
|
|
|
export class CefV8Handler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
enum CefV8PropertyAttribute {
|
|
None = 0,
|
|
ReadOnly = 1,
|
|
DontEnum = 2,
|
|
DontDelete = 4
|
|
}
|
|
|
|
export class CefV8StackFrame {
|
|
HasOneRef: boolean;
|
|
IsValid: boolean;
|
|
ScriptName: string;
|
|
ScriptNameOrSourceUrl: string;
|
|
FunctionName: string;
|
|
LineNumber: number;
|
|
Column: number;
|
|
IsEval: boolean;
|
|
IsConstructor: boolean;
|
|
Dispose(): void;
|
|
}
|
|
|
|
export class CefV8StackTrace {
|
|
HasOneRef: boolean;
|
|
IsValid: boolean;
|
|
FrameCount: number;
|
|
Dispose(): void;
|
|
static GetCurrent(frameLimit: number): Xilium.CefGlue.CefV8StackTrace;
|
|
GetFrame(index: number): Xilium.CefGlue.CefV8StackFrame;
|
|
}
|
|
|
|
export class CefV8Value {
|
|
HasOneRef: boolean;
|
|
IsValid: boolean;
|
|
IsUndefined: boolean;
|
|
IsNull: boolean;
|
|
IsBool: boolean;
|
|
IsInt: boolean;
|
|
IsUInt: boolean;
|
|
IsDouble: boolean;
|
|
IsDate: boolean;
|
|
IsString: boolean;
|
|
IsObject: boolean;
|
|
IsArray: boolean;
|
|
IsFunction: boolean;
|
|
IsUserCreated: boolean;
|
|
HasException: boolean;
|
|
Dispose(): void;
|
|
static CreateUndefined(): Xilium.CefGlue.CefV8Value;
|
|
static CreateNull(): Xilium.CefGlue.CefV8Value;
|
|
static CreateBool(value: boolean): Xilium.CefGlue.CefV8Value;
|
|
static CreateInt(value: number): Xilium.CefGlue.CefV8Value;
|
|
static CreateUInt(value: number): Xilium.CefGlue.CefV8Value;
|
|
static CreateDouble(value: number): Xilium.CefGlue.CefV8Value;
|
|
static CreateDate(value: Date): Xilium.CefGlue.CefV8Value;
|
|
static CreateString(value: string): Xilium.CefGlue.CefV8Value;
|
|
static CreateObject(accessor: Xilium.CefGlue.CefV8Accessor): Xilium.CefGlue.CefV8Value;
|
|
static CreateArray(length: number): Xilium.CefGlue.CefV8Value;
|
|
static CreateFunction(name: string, handler: Xilium.CefGlue.CefV8Handler): Xilium.CefGlue.CefV8Value;
|
|
IsSame(that: Xilium.CefGlue.CefV8Value): boolean;
|
|
GetBoolValue(): boolean;
|
|
GetIntValue(): number;
|
|
GetUIntValue(): number;
|
|
GetDoubleValue(): number;
|
|
GetDateValue(): Date;
|
|
GetStringValue(): string;
|
|
GetException(): Xilium.CefGlue.CefV8Exception;
|
|
ClearException(): boolean;
|
|
WillRethrowExceptions(): boolean;
|
|
SetRethrowExceptions(rethrow: boolean): boolean;
|
|
HasValue(key: string): boolean;
|
|
HasValue(index: number): boolean;
|
|
DeleteValue(key: string): boolean;
|
|
DeleteValue(index: number): boolean;
|
|
GetValue(key: string): Xilium.CefGlue.CefV8Value;
|
|
GetValue(index: number): Xilium.CefGlue.CefV8Value;
|
|
SetValue(key: string, value: Xilium.CefGlue.CefV8Value, attribute: Xilium.CefGlue.CefV8PropertyAttribute): boolean;
|
|
SetValue(index: number, value: Xilium.CefGlue.CefV8Value): boolean;
|
|
SetValue(key: string, settings: Xilium.CefGlue.CefV8AccessControl, attribute: Xilium.CefGlue.CefV8PropertyAttribute): boolean;
|
|
//TryGetKeys(keys: string[]&): boolean;
|
|
TryGetKeys(keys: string[]): boolean;
|
|
GetKeys(): string[];
|
|
SetUserData(userData: Xilium.CefGlue.CefUserData): boolean;
|
|
GetUserData(): Xilium.CefGlue.CefUserData;
|
|
GetExternallyAllocatedMemory(): number;
|
|
AdjustExternallyAllocatedMemory(changeInBytes: number): number;
|
|
GetArrayLength(): number;
|
|
GetFunctionName(): string;
|
|
GetFunctionHandler(): Xilium.CefGlue.CefV8Handler;
|
|
ExecuteFunction(obj: Xilium.CefGlue.CefV8Value, argumentss: Xilium.CefGlue.CefV8Value[]): Xilium.CefGlue.CefV8Value;
|
|
ExecuteFunctionWithContext(context: Xilium.CefGlue.CefV8Context, obj: Xilium.CefGlue.CefV8Value, argumentss: Xilium.CefGlue.CefV8Value[]): Xilium.CefGlue.CefV8Value;
|
|
}
|
|
|
|
enum CefValueType {
|
|
Invalid = 0,
|
|
Null = 1,
|
|
Bool = 2,
|
|
Int = 3,
|
|
Double = 4,
|
|
String = 5,
|
|
Binary = 6,
|
|
Dictionary = 7,
|
|
List = 8
|
|
}
|
|
|
|
export class CefVersionMismatchException {
|
|
constructor(message: string);
|
|
}
|
|
|
|
export class CefWebPluginInfo {
|
|
HasOneRef: boolean;
|
|
Name: string;
|
|
Path: string;
|
|
Version: string;
|
|
Description: string;
|
|
Dispose(): void;
|
|
}
|
|
|
|
export class CefWebPluginInfoVisitor {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefWebPluginUnstableCallback {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
export class CefWindowInfo {
|
|
Disposed: boolean;
|
|
ParentHandle: number;
|
|
Handle: number;
|
|
Name: string;
|
|
X: number;
|
|
Y: number;
|
|
Width: number;
|
|
Height: number;
|
|
Style: Xilium.CefGlue.Platform.Windows.WindowStyle;
|
|
StyleEx: Xilium.CefGlue.Platform.Windows.WindowStyleEx;
|
|
MenuHandle: number;
|
|
Hidden: boolean;
|
|
WindowlessRenderingEnabled: boolean;
|
|
TransparentPaintingEnabled: boolean;
|
|
static Create(): Xilium.CefGlue.CefWindowInfo;
|
|
SetAsChild(parentHandle: number, rect: Xilium.CefGlue.CefRectangle): void;
|
|
SetAsPopup(parentHandle: number, name: string): void;
|
|
SetAsWindowless(parentHandle: number, transparent: boolean): void;
|
|
}
|
|
|
|
export class CefWriteHandler {
|
|
SyncRoot: any;
|
|
}
|
|
|
|
enum CefXmlEncoding {
|
|
None = 0,
|
|
Utf8 = 1,
|
|
Utf16LE = 2,
|
|
Utf16BE = 3,
|
|
Ascii = 4
|
|
}
|
|
|
|
enum CefXmlNodeType {
|
|
Unsupported = 0,
|
|
ProcessingInstruction = 1,
|
|
DocumentType = 2,
|
|
ElementStart = 3,
|
|
ElementEnd = 4,
|
|
Attribute = 5,
|
|
Text = 6,
|
|
CData = 7,
|
|
EntityReference = 8,
|
|
WhiteSpace = 9,
|
|
Comment = 10
|
|
}
|
|
|
|
export class CefXmlReader {
|
|
HasOneRef: boolean;
|
|
HasError: boolean;
|
|
Error: string;
|
|
NodeType: Xilium.CefGlue.CefXmlNodeType;
|
|
Depth: number;
|
|
LocalName: string;
|
|
Prefix: string;
|
|
QualifiedName: string;
|
|
NamespaceUri: string;
|
|
BaseUri: string;
|
|
XmlLang: string;
|
|
IsEmptyElement: boolean;
|
|
HasValue: boolean;
|
|
Value: string;
|
|
HasAttributes: boolean;
|
|
AttributeCount: number;
|
|
LineNumber: number;
|
|
Dispose(): void;
|
|
static Create(stream: Xilium.CefGlue.CefStreamReader, encodingType: Xilium.CefGlue.CefXmlEncoding, uri: string): Xilium.CefGlue.CefXmlReader;
|
|
MoveToNextNode(): boolean;
|
|
Close(): boolean;
|
|
GetAttribute(index: number): string;
|
|
GetAttribute(qualifiedName: string): string;
|
|
GetAttribute(localName: string, namespaceUri: string): string;
|
|
GetInnerXml(): string;
|
|
GetOuterXml(): string;
|
|
MoveToAttribute(index: number): boolean;
|
|
MoveToAttribute(qualifiedName: string): boolean;
|
|
MoveToAttribute(localName: string, namespaceUri: string): boolean;
|
|
MoveToFirstAttribute(): boolean;
|
|
MoveToNextAttribute(): boolean;
|
|
MoveToCarryingElement(): boolean;
|
|
}
|
|
|
|
export class CefZipReader {
|
|
HasOneRef: boolean;
|
|
Dispose(): void;
|
|
static Create(stream: Xilium.CefGlue.CefStreamReader): Xilium.CefGlue.CefZipReader;
|
|
MoveToFirstFile(): boolean;
|
|
MoveToNextFile(): boolean;
|
|
MoveToFile(fileName: string, caseSensitive: boolean): boolean;
|
|
Close(): boolean;
|
|
GetFileName(): string;
|
|
GetFileSize(): number;
|
|
GetFileLastModified(): Date;
|
|
OpenFile(password: string): boolean;
|
|
CloseFile(): boolean;
|
|
ReadFile(buffer: any, offset: number, length: number): number;
|
|
Tell(): number;
|
|
Eof(): boolean;
|
|
}
|
|
|
|
}
|
|
declare module Xilium.CefGlue.Platform.Windows {
|
|
|
|
enum LoadLibraryFlags {
|
|
DONT_RESOLVE_DLL_REFERENCES = 1,
|
|
LOAD_LIBRARY_AS_DATAFILE = 2,
|
|
LOAD_WITH_ALTERED_SEARCH_PATH = 8,
|
|
LOAD_IGNORE_CODE_AUTHZ_LEVEL = 16,
|
|
LOAD_LIBRARY_AS_IMAGE_RESOURCE = 32,
|
|
LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE = 64
|
|
}
|
|
|
|
enum WindowStyle {
|
|
WS_OVERLAPPED = 0,
|
|
WS_MAXIMIZEBOX = 65536,
|
|
WS_TABSTOP = 65536,
|
|
WS_GROUP = 131072,
|
|
WS_MINIMIZEBOX = 131072,
|
|
WS_SIZEFRAME = 262144,
|
|
WS_SYSMENU = 524288,
|
|
WS_HSCROLL = 1048576,
|
|
WS_VSCROLL = 2097152,
|
|
WS_DLGFRAME = 4194304,
|
|
WS_BORDER = 8388608,
|
|
WS_CAPTION = 12582912,
|
|
WS_OVERLAPPEDWINDOW = 13565952,
|
|
WS_MAXIMIZE = 16777216,
|
|
WS_CLIPCHILDREN = 33554432,
|
|
WS_CLIPSIBLINGS = 67108864,
|
|
WS_DISABLED = 134217728,
|
|
WS_VISIBLE = 268435456,
|
|
WS_MINIMIZE = 536870912,
|
|
WS_CHILD = 1073741824,
|
|
WS_POPUP = 2147483648,
|
|
WS_POPUPWINDOW = 2156396544
|
|
}
|
|
|
|
enum WindowStyleEx {
|
|
WS_EX_LEFT = 0,
|
|
WS_EX_LTRREADING = 0,
|
|
WS_EX_RIGHTSCROLLBAR = 0,
|
|
WS_EX_DLGMODALFRAME = 1,
|
|
WS_EX_NOPARENTNOTIFY = 4,
|
|
WS_EX_TOPMOST = 8,
|
|
WS_EX_ACCEPTFILES = 16,
|
|
WS_EX_TRANSPARENT = 32,
|
|
WS_EX_MDICHILD = 64,
|
|
WS_EX_TOOLWINDOW = 128,
|
|
WS_EX_WINDOWEDGE = 256,
|
|
WS_EX_PALETTEWINDOW = 392,
|
|
WS_EX_CLIENTEDGE = 512,
|
|
WS_EX_OVERLAPPEDWINDOW = 768,
|
|
WS_EX_CONTEXTHELP = 1024,
|
|
WS_EX_RIGHT = 4096,
|
|
WS_EX_RTLREADING = 8192,
|
|
WS_EX_LEFTSCROLLBAR = 16384,
|
|
WS_EX_CONTROLPARENT = 65536,
|
|
WS_EX_STATICEDGE = 131072,
|
|
WS_EX_APPWINDOW = 262144,
|
|
WS_EX_LAYERED = 524288,
|
|
WS_EX_NOINHERITLAYOUT = 1048576,
|
|
WS_EX_LAYOUTRTL = 4194304,
|
|
WS_EX_COMPOSITED = 33554432,
|
|
WS_EX_NOACTIVATE = 134217728
|
|
}
|
|
|
|
}
|
|
declare module Xilium.CefGlue.Wrapper {
|
|
|
|
export class CefMessageRouterBrowserSide {
|
|
constructor(config: Xilium.CefGlue.Wrapper.CefMessageRouterConfig);
|
|
static Create(config: Xilium.CefGlue.Wrapper.CefMessageRouterConfig): Xilium.CefGlue.Wrapper.CefMessageRouterBrowserSide;
|
|
AddHandler(handler: Xilium.CefGlue.Wrapper.CefMessageRouterBrowserSide_Handler, first: boolean): boolean;
|
|
RemoveHandler(handler: Xilium.CefGlue.Wrapper.CefMessageRouterBrowserSide_Handler): boolean;
|
|
CancelPending(browser: Xilium.CefGlue.CefBrowser, handler: Xilium.CefGlue.Wrapper.CefMessageRouterBrowserSide_Handler): void;
|
|
GetPendingCount(browser: Xilium.CefGlue.CefBrowser, handler: Xilium.CefGlue.Wrapper.CefMessageRouterBrowserSide_Handler): number;
|
|
OnBeforeClose(browser: Xilium.CefGlue.CefBrowser): void;
|
|
OnRenderProcessTerminated(browser: Xilium.CefGlue.CefBrowser): void;
|
|
OnBeforeBrowse(browser: Xilium.CefGlue.CefBrowser, frame: Xilium.CefGlue.CefFrame): void;
|
|
OnProcessMessageReceived(browser: Xilium.CefGlue.CefBrowser, sourceProcess: Xilium.CefGlue.CefProcessId, message: Xilium.CefGlue.CefProcessMessage): boolean;
|
|
}
|
|
|
|
export class CefMessageRouterBrowserSide_Callback {
|
|
Success(response: string): void;
|
|
Failure(errorCode: number, errorMessage: string): void;
|
|
}
|
|
|
|
export class CefMessageRouterBrowserSide_Handler {
|
|
constructor();
|
|
OnQuery(browser: Xilium.CefGlue.CefBrowser, frame: Xilium.CefGlue.CefFrame, queryId: number, request: string, persistent: boolean, callback: Xilium.CefGlue.Wrapper.CefMessageRouterBrowserSide_Callback): boolean;
|
|
OnQueryCanceled(browser: Xilium.CefGlue.CefBrowser, frame: Xilium.CefGlue.CefFrame, queryId: number): void;
|
|
}
|
|
|
|
export class CefMessageRouterConfig {
|
|
JSQueryFunction: string;
|
|
JSCancelFunction: string;
|
|
constructor();
|
|
}
|
|
|
|
export class CefMessageRouterRendererSide {
|
|
constructor(config: Xilium.CefGlue.Wrapper.CefMessageRouterConfig);
|
|
static Create(config: Xilium.CefGlue.Wrapper.CefMessageRouterConfig): Xilium.CefGlue.Wrapper.CefMessageRouterRendererSide;
|
|
GetPendingCount(browser: Xilium.CefGlue.CefBrowser, context: Xilium.CefGlue.CefV8Context): number;
|
|
OnContextCreated(browser: Xilium.CefGlue.CefBrowser, frame: Xilium.CefGlue.CefFrame, context: Xilium.CefGlue.CefV8Context): void;
|
|
OnContextReleased(browser: Xilium.CefGlue.CefBrowser, frame: Xilium.CefGlue.CefFrame, context: Xilium.CefGlue.CefV8Context): void;
|
|
OnProcessMessageReceived(browser: Xilium.CefGlue.CefBrowser, sourceProcess: Xilium.CefGlue.CefProcessId, message: Xilium.CefGlue.CefProcessMessage): boolean;
|
|
}
|
|
|
|
}
|
|
|