diff --git a/v2/internal/frontend/desktop/darwin/Application.h b/v2/internal/frontend/desktop/darwin/Application.h index 5c4f2fe91a2..2582eb6e894 100644 --- a/v2/internal/frontend/desktop/darwin/Application.h +++ b/v2/internal/frontend/desktop/darwin/Application.h @@ -17,7 +17,7 @@ #define WindowStartsMinimised 2 #define WindowStartsFullscreen 3 -WailsContext* Create(const char* title, int width, int height, int frameless, int resizable, int zoomable, int fullscreen, int fullSizeContent, int hideTitleBar, int titlebarAppearsTransparent, int hideTitle, int useToolbar, int hideToolbarSeparator, int webviewIsTransparent, int alwaysOnTop, int hideWindowOnClose, const char *appearance, int windowIsTranslucent, int devtoolsEnabled, int defaultContextMenuEnabled, int windowStartState, int startsHidden, int minWidth, int minHeight, int maxWidth, int maxHeight, bool fraudulentWebsiteWarningEnabled, struct Preferences preferences, int singleInstanceEnabled, const char* singleInstanceUniqueId); +WailsContext* Create(const char* title, int width, int height, int frameless, int resizable, int zoomable, int fullscreen, int fullSizeContent, int hideTitleBar, int titlebarAppearsTransparent, int hideTitle, int useToolbar, int hideToolbarSeparator, int webviewIsTransparent, int alwaysOnTop, int hideWindowOnClose, const char *appearance, int windowIsTranslucent, int devtoolsEnabled, int defaultContextMenuEnabled, int windowStartState, int startsHidden, int minWidth, int minHeight, int maxWidth, int maxHeight, bool fraudulentWebsiteWarningEnabled, struct Preferences preferences, int singleInstanceEnabled, const char* singleInstanceUniqueId, bool enableDragAndDrop, bool disableWebViewDragAndDrop); void Run(void*, const char* url); void SetTitle(void* ctx, const char *title); diff --git a/v2/internal/frontend/desktop/darwin/Application.m b/v2/internal/frontend/desktop/darwin/Application.m index f0a5a2a9ac6..941e6e9223e 100644 --- a/v2/internal/frontend/desktop/darwin/Application.m +++ b/v2/internal/frontend/desktop/darwin/Application.m @@ -14,7 +14,7 @@ #import "WailsMenu.h" #import "WailsMenuItem.h" -WailsContext* Create(const char* title, int width, int height, int frameless, int resizable, int zoomable, int fullscreen, int fullSizeContent, int hideTitleBar, int titlebarAppearsTransparent, int hideTitle, int useToolbar, int hideToolbarSeparator, int webviewIsTransparent, int alwaysOnTop, int hideWindowOnClose, const char *appearance, int windowIsTranslucent, int devtoolsEnabled, int defaultContextMenuEnabled, int windowStartState, int startsHidden, int minWidth, int minHeight, int maxWidth, int maxHeight, bool fraudulentWebsiteWarningEnabled, struct Preferences preferences, int singleInstanceLockEnabled, const char* singleInstanceUniqueId) { +WailsContext* Create(const char* title, int width, int height, int frameless, int resizable, int zoomable, int fullscreen, int fullSizeContent, int hideTitleBar, int titlebarAppearsTransparent, int hideTitle, int useToolbar, int hideToolbarSeparator, int webviewIsTransparent, int alwaysOnTop, int hideWindowOnClose, const char *appearance, int windowIsTranslucent, int devtoolsEnabled, int defaultContextMenuEnabled, int windowStartState, int startsHidden, int minWidth, int minHeight, int maxWidth, int maxHeight, bool fraudulentWebsiteWarningEnabled, struct Preferences preferences, int singleInstanceLockEnabled, const char* singleInstanceUniqueId, bool enableDragAndDrop, bool disableWebViewDragAndDrop) { [NSApplication sharedApplication]; @@ -27,7 +27,7 @@ fullscreen = 1; } - [result CreateWindow:width :height :frameless :resizable :zoomable :fullscreen :fullSizeContent :hideTitleBar :titlebarAppearsTransparent :hideTitle :useToolbar :hideToolbarSeparator :webviewIsTransparent :hideWindowOnClose :safeInit(appearance) :windowIsTranslucent :minWidth :minHeight :maxWidth :maxHeight :fraudulentWebsiteWarningEnabled :preferences]; + [result CreateWindow:width :height :frameless :resizable :zoomable :fullscreen :fullSizeContent :hideTitleBar :titlebarAppearsTransparent :hideTitle :useToolbar :hideToolbarSeparator :webviewIsTransparent :hideWindowOnClose :safeInit(appearance) :windowIsTranslucent :minWidth :minHeight :maxWidth :maxHeight :fraudulentWebsiteWarningEnabled :preferences :enableDragAndDrop :disableWebViewDragAndDrop]; [result SetTitle:safeInit(title)]; [result Center]; diff --git a/v2/internal/frontend/desktop/darwin/WailsContext.h b/v2/internal/frontend/desktop/darwin/WailsContext.h index 0e83ff0a8fa..2ec6d8707df 100644 --- a/v2/internal/frontend/desktop/darwin/WailsContext.h +++ b/v2/internal/frontend/desktop/darwin/WailsContext.h @@ -10,6 +10,7 @@ #import #import +#import "WailsWebView.h" #if __has_include() #define USE_NEW_FILTERS @@ -32,7 +33,7 @@ @interface WailsContext : NSObject @property (retain) WailsWindow* mainWindow; -@property (retain) WKWebView* webview; +@property (retain) WailsWebView* webview; @property (nonatomic, assign) id appdelegate; @property bool hideOnClose; @@ -64,7 +65,7 @@ struct Preferences { bool *fullscreenEnabled; }; -- (void) CreateWindow:(int)width :(int)height :(bool)frameless :(bool)resizable :(bool)zoomable :(bool)fullscreen :(bool)fullSizeContent :(bool)hideTitleBar :(bool)titlebarAppearsTransparent :(bool)hideTitle :(bool)useToolbar :(bool)hideToolbarSeparator :(bool)webviewIsTransparent :(bool)hideWindowOnClose :(NSString *)appearance :(bool)windowIsTranslucent :(int)minWidth :(int)minHeight :(int)maxWidth :(int)maxHeight :(bool)fraudulentWebsiteWarningEnabled :(struct Preferences)preferences; +- (void) CreateWindow:(int)width :(int)height :(bool)frameless :(bool)resizable :(bool)zoomable :(bool)fullscreen :(bool)fullSizeContent :(bool)hideTitleBar :(bool)titlebarAppearsTransparent :(bool)hideTitle :(bool)useToolbar :(bool)hideToolbarSeparator :(bool)webviewIsTransparent :(bool)hideWindowOnClose :(NSString *)appearance :(bool)windowIsTranslucent :(int)minWidth :(int)minHeight :(int)maxWidth :(int)maxHeight :(bool)fraudulentWebsiteWarningEnabled :(struct Preferences)preferences :(bool)enableDragAndDrop :(bool)disableWebViewDragAndDrop; - (void) SetSize:(int)width :(int)height; - (void) SetPosition:(int)x :(int) y; - (void) SetMinSize:(int)minWidth :(int)minHeight; diff --git a/v2/internal/frontend/desktop/darwin/WailsContext.m b/v2/internal/frontend/desktop/darwin/WailsContext.m index 91c1b65fec5..581a8c13885 100644 --- a/v2/internal/frontend/desktop/darwin/WailsContext.m +++ b/v2/internal/frontend/desktop/darwin/WailsContext.m @@ -1,4 +1,3 @@ -//go:build darwin // // WailsContext.m // test @@ -11,6 +10,7 @@ #import "WailsContext.h" #import "WailsAlert.h" #import "WailsMenu.h" +#import "WailsWebView.h" #import "WindowDelegate.h" #import "message.h" #import "Role.h" @@ -39,9 +39,9 @@ - (void) disableWindowConstraints { @implementation WailsContext - (void) SetSize:(int)width :(int)height { - + if (self.shuttingDown) return; - + NSRect frame = [self.mainWindow frame]; frame.origin.y += frame.size.height - height; frame.size.width = width; @@ -50,22 +50,22 @@ - (void) SetSize:(int)width :(int)height { } - (void) SetPosition:(int)x :(int)y { - + if (self.shuttingDown) return; - + NSScreen* screen = [self getCurrentScreen]; NSRect windowFrame = [self.mainWindow frame]; NSRect screenFrame = [screen visibleFrame]; windowFrame.origin.x = screenFrame.origin.x + (float)x; windowFrame.origin.y = (screenFrame.origin.y + screenFrame.size.height) - windowFrame.size.height - (float)y; - + [self.mainWindow setFrame:windowFrame display:TRUE animate:FALSE]; } - (void) SetMinSize:(int)minWidth :(int)minHeight { - + if (self.shuttingDown) return; - + NSSize size = { minWidth, minHeight }; self.mainWindow.userMinSize = size; [self.mainWindow setMinSize:size]; @@ -74,14 +74,14 @@ - (void) SetMinSize:(int)minWidth :(int)minHeight { - (void) SetMaxSize:(int)maxWidth :(int)maxHeight { - + if (self.shuttingDown) return; - + NSSize size = { FLT_MAX, FLT_MAX }; - + size.width = maxWidth > 0 ? maxWidth : FLT_MAX; size.height = maxHeight > 0 ? maxHeight : FLT_MAX; - + self.mainWindow.userMaxSize = size; [self.mainWindow setMaxSize:size]; [self adjustWindowSize]; @@ -89,18 +89,18 @@ - (void) SetMaxSize:(int)maxWidth :(int)maxHeight { - (void) adjustWindowSize { - + if (self.shuttingDown) return; - + NSRect currentFrame = [self.mainWindow frame]; - + if ( currentFrame.size.width > self.mainWindow.userMaxSize.width ) currentFrame.size.width = self.mainWindow.userMaxSize.width; if ( currentFrame.size.width < self.mainWindow.userMinSize.width ) currentFrame.size.width = self.mainWindow.userMinSize.width; if ( currentFrame.size.height > self.mainWindow.userMaxSize.height ) currentFrame.size.height = self.mainWindow.userMaxSize.height; if ( currentFrame.size.height < self.mainWindow.userMinSize.height ) currentFrame.size.height = self.mainWindow.userMinSize.height; [self.mainWindow setFrame:currentFrame display:YES animate:FALSE]; - + } - (void) dealloc { @@ -136,16 +136,16 @@ - (BOOL) isFullscreen { return NO; } -- (void) CreateWindow:(int)width :(int)height :(bool)frameless :(bool)resizable :(bool)zoomable :(bool)fullscreen :(bool)fullSizeContent :(bool)hideTitleBar :(bool)titlebarAppearsTransparent :(bool)hideTitle :(bool)useToolbar :(bool)hideToolbarSeparator :(bool)webviewIsTransparent :(bool)hideWindowOnClose :(NSString*)appearance :(bool)windowIsTranslucent :(int)minWidth :(int)minHeight :(int)maxWidth :(int)maxHeight :(bool)fraudulentWebsiteWarningEnabled :(struct Preferences)preferences { +- (void) CreateWindow:(int)width :(int)height :(bool)frameless :(bool)resizable :(bool)zoomable :(bool)fullscreen :(bool)fullSizeContent :(bool)hideTitleBar :(bool)titlebarAppearsTransparent :(bool)hideTitle :(bool)useToolbar :(bool)hideToolbarSeparator :(bool)webviewIsTransparent :(bool)hideWindowOnClose :(NSString*)appearance :(bool)windowIsTranslucent :(int)minWidth :(int)minHeight :(int)maxWidth :(int)maxHeight :(bool)fraudulentWebsiteWarningEnabled :(struct Preferences)preferences :(bool)enableDragAndDrop :(bool)disableWebViewDragAndDrop { NSWindowStyleMask styleMask = 0; - + if( !frameless ) { if (!hideTitleBar) { styleMask |= NSWindowStyleMaskTitled; } styleMask |= NSWindowStyleMaskClosable; } - + styleMask |= NSWindowStyleMaskMiniaturizable; if( fullSizeContent || frameless || titlebarAppearsTransparent ) { @@ -155,7 +155,7 @@ - (void) CreateWindow:(int)width :(int)height :(bool)frameless :(bool)resizable if (resizable) { styleMask |= NSWindowStyleMaskResizable; } - + self.mainWindow = [[WailsWindow alloc] initWithContentRect:NSMakeRect(0, 0, width, height) styleMask:styleMask backing:NSBackingStoreBuffered defer:NO]; if (!frameless && useToolbar) { @@ -163,14 +163,14 @@ - (void) CreateWindow:(int)width :(int)height :(bool)frameless :(bool)resizable [toolbar autorelease]; [toolbar setShowsBaselineSeparator:!hideToolbarSeparator]; [self.mainWindow setToolbar:toolbar]; - + } - + [self.mainWindow setTitleVisibility:hideTitle]; [self.mainWindow setTitlebarAppearsTransparent:titlebarAppearsTransparent]; - + // [self.mainWindow canBecomeKeyWindow]; - + id contentView = [self.mainWindow contentView]; if (windowIsTranslucent) { NSVisualEffectView *effectView = [NSVisualEffectView alloc]; @@ -181,17 +181,18 @@ - (void) CreateWindow:(int)width :(int)height :(bool)frameless :(bool)resizable [effectView setState:NSVisualEffectStateActive]; [contentView addSubview:effectView positioned:NSWindowBelow relativeTo:nil]; } - + if (appearance != nil) { NSAppearance *nsAppearance = [NSAppearance appearanceNamed:appearance]; [self.mainWindow setAppearance:nsAppearance]; } - + if (!zoomable && resizable) { NSButton *button = [self.mainWindow standardWindowButton:NSWindowZoomButton]; [button setEnabled: NO]; } + NSSize minSize = { minWidth, minHeight }; NSSize maxSize = { maxWidth, maxHeight }; if (maxSize.width == 0) { @@ -202,16 +203,16 @@ - (void) CreateWindow:(int)width :(int)height :(bool)frameless :(bool)resizable } self.mainWindow.userMaxSize = maxSize; self.mainWindow.userMinSize = minSize; - + if( !fullscreen ) { [self.mainWindow applyWindowConstraints]; } - + WindowDelegate *windowDelegate = [WindowDelegate new]; windowDelegate.hideOnClose = hideWindowOnClose; windowDelegate.ctx = self; [self.mainWindow setDelegate:windowDelegate]; - + // Webview stuff here! WKWebViewConfiguration *config = [WKWebViewConfiguration new]; config.suppressesIncrementalRendering = true; @@ -261,25 +262,28 @@ - (void) CreateWindow:(int)width :(int)height :(bool)frameless :(bool)resizable forMainFrameOnly:false]; [userContentController addUserScript:initScript]; } - - self.webview = [WKWebView alloc]; + + self.webview = [WailsWebView alloc]; + self.webview.enableDragAndDrop = enableDragAndDrop; + self.webview.disableWebViewDragAndDrop = disableWebViewDragAndDrop; + CGRect init = { 0,0,0,0 }; [self.webview initWithFrame:init configuration:config]; [contentView addSubview:self.webview]; [self.webview setAutoresizingMask: NSViewWidthSizable|NSViewHeightSizable]; CGRect contentViewBounds = [contentView bounds]; [self.webview setFrame:contentViewBounds]; - + if (webviewIsTransparent) { [self.webview setValue:[NSNumber numberWithBool:!webviewIsTransparent] forKey:@"drawsBackground"]; } - + [self.webview setNavigationDelegate:self]; self.webview.UIDelegate = self; NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults]; [defaults setBool:FALSE forKey:@"NSAutomaticQuoteSubstitutionEnabled"]; - + // Mouse monitors [NSEvent addLocalMonitorForEventsMatchingMask:NSEventMaskLeftMouseDown handler:^NSEvent * _Nullable(NSEvent * _Nonnull event) { id window = [event window]; @@ -288,7 +292,7 @@ - (void) CreateWindow:(int)width :(int)height :(bool)frameless :(bool)resizable } return event; }]; - + [NSEvent addLocalMonitorForEventsMatchingMask:NSEventMaskLeftMouseUp handler:^NSEvent * _Nullable(NSEvent * _Nonnull event) { id window = [event window]; if (window == self.mainWindow) { @@ -297,9 +301,9 @@ - (void) CreateWindow:(int)width :(int)height :(bool)frameless :(bool)resizable } return event; }]; - + self.applicationMenu = [NSMenu new]; - + } - (NSMenuItem*) newMenuItem :(NSString*)title :(SEL)selector :(NSString*)key :(NSEventModifierFlags)flags { @@ -335,9 +339,9 @@ - (void) SetBackgroundColour:(int)r :(int)g :(int)b :(int)a { float green = g/255.0; float blue = b/255.0; float alpha = a/255.0; - + id colour = [NSColor colorWithCalibratedRed:red green:green blue:blue alpha:alpha ]; - + [self.mainWindow setBackgroundColor:colour]; } @@ -433,9 +437,9 @@ - (void) ExecJS:(NSString*)script { [self.webview evaluateJavaScript:script completionHandler:nil]; } -- (void)webView:(WKWebView *)webView runOpenPanelWithParameters:(WKOpenPanelParameters *)parameters +- (void)webView:(WKWebView *)webView runOpenPanelWithParameters:(WKOpenPanelParameters *)parameters initiatedByFrame:(WKFrameInfo *)frame completionHandler:(void (^)(NSArray * URLs))completionHandler { - + NSOpenPanel *openPanel = [NSOpenPanel openPanel]; openPanel.allowsMultipleSelection = parameters.allowsMultipleSelection; #if MAC_OS_X_VERSION_MAX_ALLOWED >= 101400 @@ -443,7 +447,7 @@ - (void)webView:(WKWebView *)webView runOpenPanelWithParameters:(WKOpenPanelPara openPanel.canChooseDirectories = parameters.allowsDirectories; } #endif - [openPanel + [openPanel beginSheetModalForWindow:webView.window completionHandler:^(NSInteger result) { if (result == NSModalResponseOK) @@ -474,7 +478,7 @@ - (void)webView:(WKWebView *)webView didFinishNavigation:(WKNavigation *)navigat - (void)userContentController:(nonnull WKUserContentController *)userContentController didReceiveScriptMessage:(nonnull WKScriptMessage *)message { NSString *m = message.body; - + // Check for drag if ( [m isEqualToString:@"drag"] ) { if( [self IsFullScreen] ) { @@ -485,9 +489,9 @@ - (void)userContentController:(nonnull WKUserContentController *)userContentCont } return; } - + const char *_m = [m UTF8String]; - + processMessage(_m); } @@ -496,7 +500,7 @@ - (void)userContentController:(nonnull WKUserContentController *)userContentCont -(void) MessageDialog :(NSString*)dialogType :(NSString*)title :(NSString*)message :(NSString*)button1 :(NSString*)button2 :(NSString*)button3 :(NSString*)button4 :(NSString*)defaultButton :(NSString*)cancelButton :(void*)iconData :(int)iconDataLength { WailsAlert *alert = [WailsAlert new]; - + int style = NSAlertStyleInformational; if (dialogType != nil ) { if( [dialogType isEqualToString:@"warning"] ) { @@ -513,12 +517,12 @@ -(void) MessageDialog :(NSString*)dialogType :(NSString*)title :(NSString*)messa if( message != nil ) { [alert setInformativeText:message]; } - + [alert addButton:button1 :defaultButton :cancelButton]; [alert addButton:button2 :defaultButton :cancelButton]; [alert addButton:button3 :defaultButton :cancelButton]; [alert addButton:button4 :defaultButton :cancelButton]; - + NSImage *icon = nil; if (iconData != nil) { NSData *imageData = [NSData dataWithBytes:iconData length:iconDataLength]; @@ -547,8 +551,8 @@ -(void) MessageDialog :(NSString*)dialogType :(NSString*)title :(NSString*)messa } -(void) OpenFileDialog :(NSString*)title :(NSString*)defaultFilename :(NSString*)defaultDirectory :(bool)allowDirectories :(bool)allowFiles :(bool)canCreateDirectories :(bool)treatPackagesAsDirectories :(bool)resolveAliases :(bool)showHiddenFiles :(bool)allowMultipleSelection :(NSString*)filters { - - + + // Create the dialog NSOpenPanel *dialog = [NSOpenPanel openPanel]; @@ -588,7 +592,7 @@ -(void) OpenFileDialog :(NSString*)title :(NSString*)defaultFilename :(NSString* if( defaultFilename != nil ) { [dialog setNameFieldStringValue:defaultFilename]; } - + [dialog setAllowsMultipleSelection: allowMultipleSelection]; [dialog setShowsHiddenFiles: showHiddenFiles]; @@ -624,19 +628,19 @@ -(void) OpenFileDialog :(NSString*)title :(NSString*)defaultFilename :(NSString* [nsjson release]; [arr release]; }]; - + } -(void) SaveFileDialog :(NSString*)title :(NSString*)defaultFilename :(NSString*)defaultDirectory :(bool)canCreateDirectories :(bool)treatPackagesAsDirectories :(bool)showHiddenFiles :(NSString*)filters; { - - + + // Create the dialog NSSavePanel *dialog = [NSSavePanel savePanel]; // Do not hide extension [dialog setExtensionHidden:false]; - + // Valid but appears to do nothing.... :/ if( title != nil ) { [dialog setTitle:title]; @@ -677,7 +681,7 @@ -(void) SaveFileDialog :(NSString*)title :(NSString*)defaultFilename :(NSString* if( defaultFilename != nil ) { [dialog setNameFieldStringValue:defaultFilename]; } - + // Default Directory if( defaultDirectory != nil ) { NSURL *url = [NSURL fileURLWithPath:defaultDirectory]; @@ -702,19 +706,19 @@ -(void) SaveFileDialog :(NSString*)title :(NSString*)defaultFilename :(NSString* } processSaveFileDialogResponse(""); }]; - + } - (void) SetAbout :(NSString*)title :(NSString*)description :(void*)imagedata :(int)datalen { self.aboutTitle = title; self.aboutDescription = description; - + NSData *imageData = [NSData dataWithBytes:imagedata length:datalen]; self.aboutImage = [[NSImage alloc] initWithData:imageData]; } -(void) About { - + WailsAlert *alert = [WailsAlert new]; [alert setAlertStyle:NSAlertStyleInformational]; if( self.aboutTitle != nil ) { @@ -723,8 +727,8 @@ -(void) About { if( self.aboutDescription != nil ) { [alert setInformativeText:self.aboutDescription]; } - - + + [alert.window setLevel:NSFloatingWindowLevel]; if ( self.aboutImage != nil) { [alert setIcon:self.aboutImage]; diff --git a/v2/internal/frontend/desktop/darwin/WailsWebView.h b/v2/internal/frontend/desktop/darwin/WailsWebView.h new file mode 100644 index 00000000000..b6f746cf217 --- /dev/null +++ b/v2/internal/frontend/desktop/darwin/WailsWebView.h @@ -0,0 +1,14 @@ +#ifndef WailsWebView_h +#define WailsWebView_h + +#import +#import + +// We will override WKWebView, so we can detect file drop in obj-c +// and grab their file path, to then inject into JS +@interface WailsWebView : WKWebView +@property bool disableWebViewDragAndDrop; +@property bool enableDragAndDrop; +@end + +#endif /* WailsWebView_h */ diff --git a/v2/internal/frontend/desktop/darwin/WailsWebView.m b/v2/internal/frontend/desktop/darwin/WailsWebView.m new file mode 100644 index 00000000000..de23ac79496 --- /dev/null +++ b/v2/internal/frontend/desktop/darwin/WailsWebView.m @@ -0,0 +1,122 @@ +#import "WailsWebView.h" +#import "message.h" + + +@implementation WailsWebView +@synthesize disableWebViewDragAndDrop; +@synthesize enableDragAndDrop; + +- (BOOL)prepareForDragOperation:(id)sender +{ + if ( !enableDragAndDrop ) { + return [super prepareForDragOperation: sender]; + } + + if ( disableWebViewDragAndDrop ) { + return YES; + } + + return [super prepareForDragOperation: sender]; +} + +- (BOOL)performDragOperation:(id )sender +{ + if ( !enableDragAndDrop ) { + return [super performDragOperation: sender]; + } + + NSPasteboard *pboard = [sender draggingPasteboard]; + + // if no types, then we'll just let the WKWebView handle the drag-n-drop as normal + NSArray * types = [pboard types]; + if( !types ) + return [super performDragOperation: sender]; + + // getting all NSURL types + NSArray *url_class = @[[NSURL class]]; + NSDictionary *options = @{}; + NSArray *files = [pboard readObjectsForClasses:url_class options:options]; + + // collecting all file paths + NSMutableArray *files_strs = [[NSMutableArray alloc] init]; + for (NSURL *url in files) + { + const char *fs_path = [url fileSystemRepresentation]; //Will be UTF-8 encoded + NSString *fs_path_str = [[NSString alloc] initWithCString:fs_path encoding:NSUTF8StringEncoding]; + [files_strs addObject:fs_path_str]; +// NSLog( @"performDragOperation: file path: %s", fs_path ); + } + + NSString *joined=[files_strs componentsJoinedByString:@"\n"]; + + // Release the array of file paths + [files_strs release]; + + int dragXLocation = [sender draggingLocation].x - [self frame].origin.x; + int dragYLocation = [self frame].size.height - [sender draggingLocation].y; // Y coordinate is inverted, so we need to subtract from the height + +// NSLog( @"draggingUpdated: X coord: %d", dragXLocation ); +// NSLog( @"draggingUpdated: Y coord: %d", dragYLocation ); + + NSString *message = [NSString stringWithFormat:@"DD:%d:%d:%@", dragXLocation, dragYLocation, joined]; + + const char* res = message.UTF8String; + + processMessage(res); + + if ( disableWebViewDragAndDrop ) { + return YES; + } + + return [super performDragOperation: sender]; +} + +- (NSDragOperation)draggingUpdated:(id )sender { + if ( !enableDragAndDrop ) { + return [super draggingUpdated: sender]; + } + + NSPasteboard *pboard = [sender draggingPasteboard]; + + // if no types, then we'll just let the WKWebView handle the drag-n-drop as normal + NSArray * types = [pboard types]; + if( !types ) { + return [super draggingUpdated: sender]; + } + + if ( disableWebViewDragAndDrop ) { + // we should call supper as otherwise events will not pass + [super draggingUpdated: sender]; + + // pass NSDragOperationGeneric = 4 to show regular hover for drag and drop. As we want to ignore webkit behaviours that depends on webpage + return 4; + } + + return [super draggingUpdated: sender]; +} + +- (NSDragOperation)draggingEntered:(id )sender { + if ( !enableDragAndDrop ) { + return [super draggingEntered: sender]; + } + + NSPasteboard *pboard = [sender draggingPasteboard]; + + // if no types, then we'll just let the WKWebView handle the drag-n-drop as normal + NSArray * types = [pboard types]; + if( !types ) { + return [super draggingEntered: sender]; + } + + if ( disableWebViewDragAndDrop ) { + // we should call supper as otherwise events will not pass + [super draggingEntered: sender]; + + // pass NSDragOperationGeneric = 4 to show regular hover for drag and drop. As we want to ignore webkit behaviours that depends on webpage + return 4; + } + + return [super draggingEntered: sender]; +} + +@end diff --git a/v2/internal/frontend/desktop/darwin/frontend.go b/v2/internal/frontend/desktop/darwin/frontend.go index 2f15ab56666..ba00b02d99c 100644 --- a/v2/internal/frontend/desktop/darwin/frontend.go +++ b/v2/internal/frontend/desktop/darwin/frontend.go @@ -368,6 +368,11 @@ func (f *Frontend) processMessage(message string) { if message == "runtime:ready" { cmd := fmt.Sprintf("window.wails.setCSSDragProperties('%s', '%s');", f.frontendOptions.CSSDragProperty, f.frontendOptions.CSSDragValue) f.ExecJS(cmd) + + if f.frontendOptions.DragAndDrop != nil && f.frontendOptions.DragAndDrop.EnableFileDrop { + f.ExecJS("window.wails.flags.enableWailsDragAndDrop = true;") + } + return } diff --git a/v2/internal/frontend/desktop/darwin/window.go b/v2/internal/frontend/desktop/darwin/window.go index 458c81eb150..121533a3393 100644 --- a/v2/internal/frontend/desktop/darwin/window.go +++ b/v2/internal/frontend/desktop/darwin/window.go @@ -83,6 +83,9 @@ func NewWindow(frontendOptions *options.App, debug bool, devtools bool) *Window enableFraudulentWebsiteWarnings := C.bool(frontendOptions.EnableFraudulentWebsiteDetection) + enableDragAndDrop := C.bool(frontendOptions.DragAndDrop != nil && frontendOptions.DragAndDrop.EnableFileDrop) + disableWebViewDragAndDrop := C.bool(frontendOptions.DragAndDrop != nil && frontendOptions.DragAndDrop.DisableWebViewDrop) + if frontendOptions.Mac != nil { mac := frontendOptions.Mac if mac.TitleBar != nil { @@ -119,7 +122,7 @@ func NewWindow(frontendOptions *options.App, debug bool, devtools bool) *Window hideTitleBar, titlebarAppearsTransparent, hideTitle, useToolbar, hideToolbarSeparator, webviewIsTransparent, alwaysOnTop, hideWindowOnClose, appearance, windowIsTranslucent, devtoolsEnabled, defaultContextMenuEnabled, windowStartState, startsHidden, minWidth, minHeight, maxWidth, maxHeight, enableFraudulentWebsiteWarnings, - preferences, singleInstanceEnabled, singleInstanceUniqueId, + preferences, singleInstanceEnabled, singleInstanceUniqueId, enableDragAndDrop, disableWebViewDragAndDrop, ) // Create menu diff --git a/v2/internal/frontend/desktop/linux/frontend.go b/v2/internal/frontend/desktop/linux/frontend.go index f742a54206b..3bc81649f59 100644 --- a/v2/internal/frontend/desktop/linux/frontend.go +++ b/v2/internal/frontend/desktop/linux/frontend.go @@ -444,12 +444,24 @@ func (f *Frontend) processMessage(message string) { if message == "runtime:ready" { cmd := fmt.Sprintf( "window.wails.setCSSDragProperties('%s', '%s');\n"+ - "window.wails.flags.deferDragToMouseMove = true;", f.frontendOptions.CSSDragProperty, f.frontendOptions.CSSDragValue) + "window.wails.setCSSDropProperties('%s', '%s');\n"+ + "window.wails.flags.deferDragToMouseMove = true;", + f.frontendOptions.CSSDragProperty, + f.frontendOptions.CSSDragValue, + f.frontendOptions.DragAndDrop.CSSDropProperty, + f.frontendOptions.DragAndDrop.CSSDropValue, + ) + f.ExecJS(cmd) if f.frontendOptions.Frameless && f.frontendOptions.DisableResize == false { f.ExecJS("window.wails.flags.enableResize = true;") } + + if f.frontendOptions.DragAndDrop.EnableFileDrop { + f.ExecJS("window.wails.flags.enableWailsDragAndDrop = true;") + } + return } diff --git a/v2/internal/frontend/desktop/linux/window.c b/v2/internal/frontend/desktop/linux/window.c index 0000b65548c..49de5197803 100644 --- a/v2/internal/frontend/desktop/linux/window.c +++ b/v2/internal/frontend/desktop/linux/window.c @@ -4,6 +4,7 @@ #include #include #include +#include #include #include "window.h" @@ -429,14 +430,92 @@ gboolean close_button_pressed(GtkWidget *widget, GdkEvent *event, void *data) return TRUE; } +char *droppedFiles = NULL; + +static void onDragDataReceived(GtkWidget *self, GdkDragContext *context, gint x, gint y, GtkSelectionData *selection_data, guint target_type, guint time, gpointer data) +{ + if(selection_data == NULL || (gtk_selection_data_get_length(selection_data) <= 0) || target_type != 2) + { + return; + } + + if(droppedFiles != NULL) { + free(droppedFiles); + droppedFiles = NULL; + } + + gchar **filenames = NULL; + filenames = g_uri_list_extract_uris((const gchar *)gtk_selection_data_get_data(selection_data)); + if (filenames == NULL) // If unable to retrieve filenames: + { + g_strfreev(filenames); + return; + } + + droppedFiles = calloc((size_t)gtk_selection_data_get_length(selection_data), 1); + + int iter = 0; + while(filenames[iter] != NULL) // The last URI list element is NULL. + { + if(iter != 0) + { + strncat(droppedFiles, "\n", 1); + } + char *filename = g_filename_from_uri(filenames[iter], NULL, NULL); + if (filename == NULL) + { + break; + } + strncat(droppedFiles, filename, strlen(filename)); + + free(filename); + iter++; + } + + g_strfreev(filenames); +} + +static gboolean onDragDrop(GtkWidget* self, GdkDragContext* context, gint x, gint y, guint time, gpointer user_data) +{ + if(droppedFiles == NULL) + { + return FALSE; + } + + size_t resLen = strlen(droppedFiles)+(sizeof(gint)*2)+6; + char *res = calloc(resLen, 1); + + snprintf(res, resLen, "DD:%d:%d:%s", x, y, droppedFiles); + + if(droppedFiles != NULL) { + free(droppedFiles); + droppedFiles = NULL; + } + + processMessage(res); + return FALSE; +} + // WebView -GtkWidget *SetupWebview(void *contentManager, GtkWindow *window, int hideWindowOnClose, int gpuPolicy) +GtkWidget *SetupWebview(void *contentManager, GtkWindow *window, int hideWindowOnClose, int gpuPolicy, int disableWebViewDragAndDrop, int enableDragAndDrop) { GtkWidget *webview = webkit_web_view_new_with_user_content_manager((WebKitUserContentManager *)contentManager); // gtk_container_add(GTK_CONTAINER(window), webview); WebKitWebContext *context = webkit_web_context_get_default(); webkit_web_context_register_uri_scheme(context, "wails", (WebKitURISchemeRequestCallback)processURLRequest, NULL, NULL); g_signal_connect(G_OBJECT(webview), "load-changed", G_CALLBACK(webviewLoadChanged), NULL); + + if(disableWebViewDragAndDrop) + { + gtk_drag_dest_unset(G_OBJECT(webview)); + } + + if(enableDragAndDrop) + { + g_signal_connect(G_OBJECT(webview), "drag-data-received", G_CALLBACK(onDragDataReceived), NULL); + g_signal_connect(G_OBJECT(webview), "drag-drop", G_CALLBACK(onDragDrop), NULL); + } + if (hideWindowOnClose) { g_signal_connect(GTK_WIDGET(window), "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL); diff --git a/v2/internal/frontend/desktop/linux/window.go b/v2/internal/frontend/desktop/linux/window.go index 39867d69e3b..0bf5ac51d1f 100644 --- a/v2/internal/frontend/desktop/linux/window.go +++ b/v2/internal/frontend/desktop/linux/window.go @@ -103,6 +103,8 @@ func NewWindow(appoptions *options.App, debug bool, devtoolsEnabled bool) *Windo result.asGTKWindow(), bool2Cint(appoptions.HideWindowOnClose), C.int(webviewGpuPolicy), + bool2Cint(appoptions.DragAndDrop != nil && appoptions.DragAndDrop.DisableWebViewDrop), + bool2Cint(appoptions.DragAndDrop != nil && appoptions.DragAndDrop.EnableFileDrop), ) result.webview = unsafe.Pointer(webview) buttonPressedName := C.CString("button-press-event") diff --git a/v2/internal/frontend/desktop/linux/window.h b/v2/internal/frontend/desktop/linux/window.h index aa9499d73ed..04410959a9a 100644 --- a/v2/internal/frontend/desktop/linux/window.h +++ b/v2/internal/frontend/desktop/linux/window.h @@ -106,7 +106,7 @@ gboolean Fullscreen(gpointer data); gboolean UnFullscreen(gpointer data); // WebView -GtkWidget *SetupWebview(void *contentManager, GtkWindow *window, int hideWindowOnClose, int gpuPolicy); +GtkWidget *SetupWebview(void *contentManager, GtkWindow *window, int hideWindowOnClose, int gpuPolicy, int disableWebViewDragAndDrop, int enableDragAndDrop); void LoadIndex(void *webview, char *url); void DevtoolsEnabled(void *webview, int enabled, bool showInspector); void ExecuteJS(void *data); diff --git a/v2/internal/frontend/desktop/windows/frontend.go b/v2/internal/frontend/desktop/windows/frontend.go index 97eef741feb..71e90e8e5c6 100644 --- a/v2/internal/frontend/desktop/windows/frontend.go +++ b/v2/internal/frontend/desktop/windows/frontend.go @@ -16,6 +16,7 @@ import ( "sync" "text/template" "time" + "unsafe" "github.com/bep/debounce" "github.com/wailsapp/go-webview2/pkg/edge" @@ -461,7 +462,14 @@ func (f *Frontend) setupChromium() { chromium.AdditionalBrowserArgs = append(chromium.AdditionalBrowserArgs, arg) } + if f.frontendOptions.DragAndDrop != nil && f.frontendOptions.DragAndDrop.DisableWebViewDrop { + if err := chromium.AllowExternalDrag(false); err != nil { + f.logger.Warning("WebView failed to set AllowExternalDrag to false!") + } + } + chromium.MessageCallback = f.processMessage + chromium.MessageWithAdditionalObjectsCallback = f.processMessageWithAdditionalObjects chromium.WebResourceRequestedCallback = f.processRequest chromium.NavigationCompletedCallback = f.navigationCompleted chromium.AcceleratorKeyCallback = func(vkey uint) bool { @@ -673,7 +681,15 @@ func (f *Frontend) processMessage(message string) { } if message == "runtime:ready" { - cmd := fmt.Sprintf("window.wails.setCSSDragProperties('%s', '%s');", f.frontendOptions.CSSDragProperty, f.frontendOptions.CSSDragValue) + cmd := fmt.Sprintf( + "window.wails.setCSSDragProperties('%s', '%s');\n"+ + "window.wails.setCSSDropProperties('%s', '%s');", + f.frontendOptions.CSSDragProperty, + f.frontendOptions.CSSDragValue, + f.frontendOptions.DragAndDrop.CSSDropProperty, + f.frontendOptions.DragAndDrop.CSSDropValue, + ) + f.ExecJS(cmd) return } @@ -694,25 +710,81 @@ func (f *Frontend) processMessage(message string) { return } - go func() { - result, err := f.dispatcher.ProcessMessage(message, f) + go f.dispatchMessage(message) +} + +func (f *Frontend) processMessageWithAdditionalObjects(message string, sender *edge.ICoreWebView2, args *edge.ICoreWebView2WebMessageReceivedEventArgs) { + if strings.HasPrefix(message, "file:drop") { + if !f.frontendOptions.DragAndDrop.EnableFileDrop { + return + } + objs, err := args.GetAdditionalObjects() if err != nil { f.logger.Error(err.Error()) - f.Callback(result) return } - if result == "" { + + defer objs.Release() + + count, err := objs.GetCount() + if err != nil { + f.logger.Error(err.Error()) return } - switch result[0] { - case 'c': - // Callback from a method call - f.Callback(result[1:]) - default: - f.logger.Info("Unknown message returned from dispatcher: %+v", result) + files := make([]string, count) + for i := uint32(0); i < count; i++ { + _file, err := objs.GetValueAtIndex(i) + if err != nil { + f.logger.Error("cannot get value at %d : %s", i, err.Error()) + return + } + + file := (*edge.ICoreWebView2File)(unsafe.Pointer(_file)) + defer file.Release() + + filepath, err := file.GetPath() + if err != nil { + f.logger.Error("cannot get path for object at %d : %s", i, err.Error()) + return + } + + files[i] = filepath } - }() + + var ( + x = "0" + y = "0" + ) + coords := strings.SplitN(message[10:], ":", 2) + if len(coords) == 2 { + x = coords[0] + y = coords[1] + } + + go f.dispatchMessage(fmt.Sprintf("DD:%s:%s:%s", x, y, strings.Join(files, "\n"))) + return + } +} + +func (f *Frontend) dispatchMessage(message string) { + result, err := f.dispatcher.ProcessMessage(message, f) + if err != nil { + f.logger.Error(err.Error()) + f.Callback(result) + return + } + if result == "" { + return + } + + switch result[0] { + case 'c': + // Callback from a method call + f.Callback(result[1:]) + default: + f.logger.Info("Unknown message returned from dispatcher: %+v", result) + } } func (f *Frontend) Callback(message string) { @@ -758,6 +830,10 @@ func (f *Frontend) navigationCompleted(sender *edge.ICoreWebView2, args *edge.IC f.ExecJS("window.wails.flags.enableResize = true;") } + if f.frontendOptions.DragAndDrop != nil && f.frontendOptions.DragAndDrop.EnableFileDrop { + f.ExecJS("window.wails.flags.enableWailsDragAndDrop = true;") + } + if f.hasStarted { return } diff --git a/v2/internal/frontend/dispatcher/dispatcher.go b/v2/internal/frontend/dispatcher/dispatcher.go index 56092d370eb..97d9b32e951 100644 --- a/v2/internal/frontend/dispatcher/dispatcher.go +++ b/v2/internal/frontend/dispatcher/dispatcher.go @@ -2,7 +2,6 @@ package dispatcher import ( "context" - "github.com/pkg/errors" "github.com/wailsapp/wails/v2/internal/binding" "github.com/wailsapp/wails/v2/internal/frontend" @@ -47,6 +46,8 @@ func (d *Dispatcher) ProcessMessage(message string, sender frontend.Frontend) (s return d.processWindowMessage(message, sender) case 'B': return d.processBrowserMessage(message, sender) + case 'D': + return d.processDragAndDropMessage(message) case 'Q': sender.Quit() return "", nil diff --git a/v2/internal/frontend/dispatcher/draganddrop.go b/v2/internal/frontend/dispatcher/draganddrop.go new file mode 100644 index 00000000000..8266ec712f7 --- /dev/null +++ b/v2/internal/frontend/dispatcher/draganddrop.go @@ -0,0 +1,38 @@ +package dispatcher + +import ( + "errors" + "strconv" + "strings" +) + +func (d *Dispatcher) processDragAndDropMessage(message string) (string, error) { + switch message[1] { + case 'D': + msg := strings.SplitN(message[3:], ":", 3) + if len(msg) != 3 { + return "", errors.New("Invalid drag and drop Message: " + message) + } + + x, err := strconv.Atoi(msg[0]) + if err != nil { + return "", errors.New("Invalid x coordinate in drag and drop Message: " + message) + } + + y, err := strconv.Atoi(msg[1]) + if err != nil { + return "", errors.New("Invalid y coordinate in drag and drop Message: " + message) + } + + paths := strings.Split(msg[2], "\n") + if len(paths) < 1 { + return "", errors.New("Invalid drag and drop Message: " + message) + } + + d.events.Emit("wails:file-drop", x, y, paths) + default: + return "", errors.New("Invalid drag and drop Message: " + message) + } + + return "", nil +} diff --git a/v2/internal/frontend/runtime/desktop/draganddrop.js b/v2/internal/frontend/runtime/desktop/draganddrop.js new file mode 100644 index 00000000000..143b4228e76 --- /dev/null +++ b/v2/internal/frontend/runtime/desktop/draganddrop.js @@ -0,0 +1,243 @@ +/* + _ __ _ __ +| | / /___ _(_) /____ +| | /| / / __ `/ / / ___/ +| |/ |/ / /_/ / / (__ ) +|__/|__/\__,_/_/_/____/ +The electron alternative for Go +(c) Lea Anthony 2019-present +*/ + +/* jshint esversion: 9 */ + +import {EventsOn, EventsOff} from "./events"; + +const flags = { + registered: false, + defaultUseDropTarget: true, + useDropTarget: true, + nextDeactivate: null, + nextDeactivateTimeout: null, +}; + +const DROP_TARGET_ACTIVE = "wails-drop-target-active"; + +/** + * checkStyleDropTarget checks if the style has the drop target attribute + * + * @param {CSSStyleDeclaration} style + * @returns + */ +function checkStyleDropTarget(style) { + const cssDropValue = style.getPropertyValue(window.wails.flags.cssDropProperty).trim(); + if (cssDropValue) { + if (cssDropValue === window.wails.flags.cssDropValue) { + return true; + } + // if the element has the drop target attribute, but + // the value is not correct, terminate finding process. + // This can be useful to block some child elements from being drop targets. + return false; + } + return false; +} + +/** + * onDragOver is called when the dragover event is emitted. + * @param {DragEvent} e + * @returns + */ +function onDragOver(e) { + if (!window.wails.flags.enableWailsDragAndDrop) { + return; + } + e.preventDefault(); + + if (!flags.useDropTarget) { + return; + } + + const element = e.target; + + // Trigger debounce function to deactivate drop targets + if(flags.nextDeactivate) flags.nextDeactivate(); + + // if the element is null or element is not child of drop target element + if (!element || !checkStyleDropTarget(getComputedStyle(element))) { + return; + } + + let currentElement = element; + while (currentElement) { + // check if currentElement is drop target element + if (checkStyleDropTarget(currentElement.style)) { + currentElement.classList.add(DROP_TARGET_ACTIVE); + } + currentElement = currentElement.parentElement; + } +} + +/** + * onDragLeave is called when the dragleave event is emitted. + * @param {DragEvent} e + * @returns + */ +function onDragLeave(e) { + if (!window.wails.flags.enableWailsDragAndDrop) { + return; + } + e.preventDefault(); + + if (!flags.useDropTarget) { + return; + } + + // Find the close drop target element + if (!e.target || !checkStyleDropTarget(getComputedStyle(e.target))) { + return null; + } + + // Trigger debounce function to deactivate drop targets + if(flags.nextDeactivate) flags.nextDeactivate(); + + // Use debounce technique to tacle dragleave events on overlapping elements and drop target elements + flags.nextDeactivate = () => { + // Deactivate all drop targets, new drop target will be activated on next dragover event + Array.from(document.getElementsByClassName(DROP_TARGET_ACTIVE)).forEach(el => el.classList.remove(DROP_TARGET_ACTIVE)); + // Reset nextDeactivate + flags.nextDeactivate = null; + // Clear timeout + if (flags.nextDeactivateTimeout) { + clearTimeout(flags.nextDeactivateTimeout); + flags.nextDeactivateTimeout = null; + } + } + + // Set timeout to deactivate drop targets if not triggered by next drag event + flags.nextDeactivateTimeout = setTimeout(() => { + if(flags.nextDeactivate) flags.nextDeactivate(); + }, 50); +} + +/** + * onDrop is called when the drop event is emitted. + * @param {DragEvent} e + * @returns + */ +function onDrop(e) { + if (!window.wails.flags.enableWailsDragAndDrop) { + return; + } + e.preventDefault(); + + if (!flags.useDropTarget) { + return; + } + + // Trigger debounce function to deactivate drop targets + if(flags.nextDeactivate) flags.nextDeactivate(); + + // Deactivate all drop targets + Array.from(document.getElementsByClassName(DROP_TARGET_ACTIVE)).forEach(el => el.classList.remove(DROP_TARGET_ACTIVE)); + + if (CanResolveFilePaths()) { + // process files + let files = []; + if (e.dataTransfer.items) { + files = [...e.dataTransfer.items].map((item, i) => { + if (item.kind === 'file') { + return item.getAsFile(); + } + }); + } else { + files = [...e.dataTransfer.files]; + } + window.runtime.ResolveFilePaths(e.x, e.y, files); + } +} + +/** + * postMessageWithAdditionalObjects checks the browser's capability of sending postMessageWithAdditionalObjects + * + * @returns {boolean} + * @constructor + */ +export function CanResolveFilePaths() { + return window.chrome?.webview?.postMessageWithAdditionalObjects != null; +} + +/** + * ResolveFilePaths sends drop events to the GO side to resolve file paths on windows. + * + * @param {number} x + * @param {number} y + * @param {any[]} files + * @constructor + */ +export function ResolveFilePaths(x, y, files) { + // Only for windows webview2 >= 1.0.1774.30 + // https://learn.microsoft.com/en-us/microsoft-edge/webview2/reference/win32/icorewebview2webmessagereceivedeventargs2?view=webview2-1.0.1823.32#applies-to + if (window.chrome?.webview?.postMessageWithAdditionalObjects) { + chrome.webview.postMessageWithAdditionalObjects(`file:drop:${x}:${y}`, files); + } +} + +/** + * Callback for OnFileDrop returns a slice of file path strings when a drop is finished. + * + * @export + * @callback OnFileDropCallback + * @param {number} x - x coordinate of the drop + * @param {number} y - y coordinate of the drop + * @param {string[]} paths - A list of file paths. + */ + +/** + * OnFileDrop listens to drag and drop events and calls the callback with the coordinates of the drop and an array of path strings. + * + * @export + * @param {OnFileDropCallback} callback - Callback for OnFileDrop returns a slice of file path strings when a drop is finished. + * @param {boolean} [useDropTarget=true] - Only call the callback when the drop finished on an element that has the drop target style. (--wails-drop-target) + */ +export function OnFileDrop(callback, useDropTarget) { + if (typeof callback !== "function") { + console.error("DragAndDropCallback is not a function"); + return; + } + + if (flags.registered) { + return; + } + flags.registered = true; + + const uDTPT = typeof useDropTarget; + flags.useDropTarget = uDTPT === "undefined" || uDTPT !== "boolean" ? flags.defaultUseDropTarget : useDropTarget; + window.addEventListener('dragover', onDragOver); + window.addEventListener('dragleave', onDragLeave); + window.addEventListener('drop', onDrop); + + let cb = callback; + if (flags.useDropTarget) { + cb = function (x, y, paths) { + const element = document.elementFromPoint(x, y) + // if the element is null or element is not child of drop target element, return null + if (!element || !checkStyleDropTarget(getComputedStyle(element))) { + return null; + } + callback(x, y, paths); + } + } + + EventsOn("wails:file-drop", cb); +} + +/** + * OnFileDropOff removes the drag and drop listeners and handlers. + */ +export function OnFileDropOff() { + window.removeEventListener('dragover', onDragOver); + window.removeEventListener('dragleave', onDragLeave); + window.removeEventListener('drop', onDrop); + EventsOff("wails:file-drop"); + flags.registered = false; +} diff --git a/v2/internal/frontend/runtime/desktop/main.js b/v2/internal/frontend/runtime/desktop/main.js index 65d954d95c1..ae31744ccb7 100644 --- a/v2/internal/frontend/runtime/desktop/main.js +++ b/v2/internal/frontend/runtime/desktop/main.js @@ -16,9 +16,9 @@ import * as Window from "./window"; import * as Screen from "./screen"; import * as Browser from "./browser"; import * as Clipboard from "./clipboard"; +import * as DragAndDrop from "./draganddrop"; import * as ContextMenu from "./contextmenu"; - export function Quit() { window.WailsInvoke('Q'); } @@ -42,6 +42,7 @@ window.runtime = { ...Browser, ...Screen, ...Clipboard, + ...DragAndDrop, EventsOn, EventsOnce, EventsOnMultiple, @@ -70,6 +71,9 @@ window.wails = { deferDragToMouseMove: true, cssDragProperty: "--wails-draggable", cssDragValue: "drag", + cssDropProperty: "--wails-drop-target", + cssDropValue: "drop", + enableWailsDragAndDrop: false, } }; @@ -112,8 +116,12 @@ window.wails.setCSSDragProperties = function (property, value) { window.wails.flags.cssDragValue = value; } -window.addEventListener('mousedown', (e) => { +window.wails.setCSSDropProperties = function (property, value) { + window.wails.flags.cssDropProperty = property; + window.wails.flags.cssDropValue = value; +} +window.addEventListener('mousedown', (e) => { // Check for resizing if (window.wails.flags.resizeEdge) { window.WailsInvoke("resize:" + window.wails.flags.resizeEdge); diff --git a/v2/internal/frontend/runtime/runtime_debug_desktop.js b/v2/internal/frontend/runtime/runtime_debug_desktop.js index e680df85de5..888fd742ab8 100644 --- a/v2/internal/frontend/runtime/runtime_debug_desktop.js +++ b/v2/internal/frontend/runtime/runtime_debug_desktop.js @@ -424,6 +424,147 @@ return Call(":wails:ClipboardGetText"); } + // desktop/draganddrop.js + var draganddrop_exports = {}; + __export(draganddrop_exports, { + CanResolveFilePaths: () => CanResolveFilePaths, + OnFileDrop: () => OnFileDrop, + OnFileDropOff: () => OnFileDropOff, + ResolveFilePaths: () => ResolveFilePaths + }); + var flags = { + registered: false, + defaultUseDropTarget: true, + useDropTarget: true, + nextDeactivate: null, + nextDeactivateTimeout: null + }; + var DROP_TARGET_ACTIVE = "wails-drop-target-active"; + function checkStyleDropTarget(style) { + const cssDropValue = style.getPropertyValue(window.wails.flags.cssDropProperty).trim(); + if (cssDropValue) { + if (cssDropValue === window.wails.flags.cssDropValue) { + return true; + } + return false; + } + return false; + } + function onDragOver(e) { + if (!window.wails.flags.enableWailsDragAndDrop) { + return; + } + e.preventDefault(); + if (!flags.useDropTarget) { + return; + } + const element = e.target; + if (flags.nextDeactivate) + flags.nextDeactivate(); + if (!element || !checkStyleDropTarget(getComputedStyle(element))) { + return; + } + let currentElement = element; + while (currentElement) { + if (checkStyleDropTarget(currentElement.style)) { + currentElement.classList.add(DROP_TARGET_ACTIVE); + } + currentElement = currentElement.parentElement; + } + } + function onDragLeave(e) { + if (!window.wails.flags.enableWailsDragAndDrop) { + return; + } + e.preventDefault(); + if (!flags.useDropTarget) { + return; + } + if (!e.target || !checkStyleDropTarget(getComputedStyle(e.target))) { + return null; + } + if (flags.nextDeactivate) + flags.nextDeactivate(); + flags.nextDeactivate = () => { + Array.from(document.getElementsByClassName(DROP_TARGET_ACTIVE)).forEach((el) => el.classList.remove(DROP_TARGET_ACTIVE)); + flags.nextDeactivate = null; + if (flags.nextDeactivateTimeout) { + clearTimeout(flags.nextDeactivateTimeout); + flags.nextDeactivateTimeout = null; + } + }; + flags.nextDeactivateTimeout = setTimeout(() => { + if (flags.nextDeactivate) + flags.nextDeactivate(); + }, 50); + } + function onDrop(e) { + if (!window.wails.flags.enableWailsDragAndDrop) { + return; + } + e.preventDefault(); + if (!flags.useDropTarget) { + return; + } + if (flags.nextDeactivate) + flags.nextDeactivate(); + Array.from(document.getElementsByClassName(DROP_TARGET_ACTIVE)).forEach((el) => el.classList.remove(DROP_TARGET_ACTIVE)); + if (CanResolveFilePaths()) { + let files = []; + if (e.dataTransfer.items) { + files = [...e.dataTransfer.items].map((item, i) => { + if (item.kind === "file") { + return item.getAsFile(); + } + }); + } else { + files = [...e.dataTransfer.files]; + } + window.runtime.ResolveFilePaths(e.x, e.y, files); + } + } + function CanResolveFilePaths() { + return window.chrome?.webview?.postMessageWithAdditionalObjects != null; + } + function ResolveFilePaths(x, y, files) { + if (window.chrome?.webview?.postMessageWithAdditionalObjects) { + chrome.webview.postMessageWithAdditionalObjects(`file:drop:${x}:${y}`, files); + } + } + function OnFileDrop(callback, useDropTarget) { + if (typeof callback !== "function") { + console.error("DragAndDropCallback is not a function"); + return; + } + if (flags.registered) { + return; + } + flags.registered = true; + const uDTPT = typeof useDropTarget; + flags.useDropTarget = uDTPT === "undefined" || uDTPT !== "boolean" ? flags.defaultUseDropTarget : useDropTarget; + window.addEventListener("dragover", onDragOver); + window.addEventListener("dragleave", onDragLeave); + window.addEventListener("drop", onDrop); + let cb = callback; + if (flags.useDropTarget) { + cb = function(x, y, paths) { + const element = document.elementFromPoint(x, y); + if (!element || !checkStyleDropTarget(getComputedStyle(element))) { + return null; + } + callback(x, y, paths); + }; + } + EventsOn("wails:file-drop", cb); + } + function OnFileDropOff() { + window.removeEventListener("dragover", onDragOver); + window.removeEventListener("dragleave", onDragLeave); + window.removeEventListener("drop", onDrop); + EventsOff("wails:file-drop"); + flags.registered = false; + } + // desktop/contextmenu.js function processDefaultContextMenu(event) { const element = event.target; @@ -481,6 +622,7 @@ ...browser_exports, ...screen_exports, ...clipboard_exports, + ...draganddrop_exports, EventsOn, EventsOnce, EventsOnMultiple, @@ -506,7 +648,10 @@ shouldDrag: false, deferDragToMouseMove: true, cssDragProperty: "--wails-draggable", - cssDragValue: "drag" + cssDragValue: "drag", + cssDropProperty: "--wails-drop-target", + cssDropValue: "drop", + enableWailsDragAndDrop: false } }; if (window.wailsbindings) { @@ -536,6 +681,10 @@ window.wails.flags.cssDragProperty = property; window.wails.flags.cssDragValue = value; }; + window.wails.setCSSDropProperties = function(property, value) { + window.wails.flags.cssDropProperty = property; + window.wails.flags.cssDropValue = value; + }; window.addEventListener("mousedown", (e) => { if (window.wails.flags.resizeEdge) { window.WailsInvoke("resize:" + window.wails.flags.resizeEdge); @@ -618,4 +767,4 @@ }); window.WailsInvoke("runtime:ready"); })(); -//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["desktop/log.js", "desktop/events.js", "desktop/calls.js", "desktop/bindings.js", "desktop/window.js", "desktop/screen.js", "desktop/browser.js", "desktop/clipboard.js", "desktop/contextmenu.js", "desktop/main.js"],
  "sourcesContent": ["/*\n _       __      _ __\n| |     / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 6 */\n\n/**\n * Sends a log message to the backend with the given level + message\n *\n * @param {string} level\n * @param {string} message\n */\nfunction sendLogMessage(level, message) {\n\n\t// Log Message format:\n\t// l[type][message]\n\twindow.WailsInvoke('L' + level + message);\n}\n\n/**\n * Log the given trace message with the backend\n *\n * @export\n * @param {string} message\n */\nexport function LogTrace(message) {\n\tsendLogMessage('T', message);\n}\n\n/**\n * Log the given message with the backend\n *\n * @export\n * @param {string} message\n */\nexport function LogPrint(message) {\n\tsendLogMessage('P', message);\n}\n\n/**\n * Log the given debug message with the backend\n *\n * @export\n * @param {string} message\n */\nexport function LogDebug(message) {\n\tsendLogMessage('D', message);\n}\n\n/**\n * Log the given info message with the backend\n *\n * @export\n * @param {string} message\n */\nexport function LogInfo(message) {\n\tsendLogMessage('I', message);\n}\n\n/**\n * Log the given warning message with the backend\n *\n * @export\n * @param {string} message\n */\nexport function LogWarning(message) {\n\tsendLogMessage('W', message);\n}\n\n/**\n * Log the given error message with the backend\n *\n * @export\n * @param {string} message\n */\nexport function LogError(message) {\n\tsendLogMessage('E', message);\n}\n\n/**\n * Log the given fatal message with the backend\n *\n * @export\n * @param {string} message\n */\nexport function LogFatal(message) {\n\tsendLogMessage('F', message);\n}\n\n/**\n * Sets the Log level to the given log level\n *\n * @export\n * @param {number} loglevel\n */\nexport function SetLogLevel(loglevel) {\n\tsendLogMessage('S', loglevel);\n}\n\n// Log levels\nexport const LogLevel = {\n\tTRACE: 1,\n\tDEBUG: 2,\n\tINFO: 3,\n\tWARNING: 4,\n\tERROR: 5,\n};\n", "/*\n _       __      _ __\n| |     / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n/* jshint esversion: 6 */\n\n// Defines a single listener with a maximum number of times to callback\n\n/**\n * The Listener class defines a listener! :-)\n *\n * @class Listener\n */\nclass Listener {\n    /**\n     * Creates an instance of Listener.\n     * @param {string} eventName\n     * @param {function} callback\n     * @param {number} maxCallbacks\n     * @memberof Listener\n     */\n    constructor(eventName, callback, maxCallbacks) {\n        this.eventName = eventName;\n        // Default of -1 means infinite\n        this.maxCallbacks = maxCallbacks || -1;\n        // Callback invokes the callback with the given data\n        // Returns true if this listener should be destroyed\n        this.Callback = (data) => {\n            callback.apply(null, data);\n            // If maxCallbacks is infinite, return false (do not destroy)\n            if (this.maxCallbacks === -1) {\n                return false;\n            }\n            // Decrement maxCallbacks. Return true if now 0, otherwise false\n            this.maxCallbacks -= 1;\n            return this.maxCallbacks === 0;\n        };\n    }\n}\n\nexport const eventListeners = {};\n\n/**\n * Registers an event listener that will be invoked `maxCallbacks` times before being destroyed\n *\n * @export\n * @param {string} eventName\n * @param {function} callback\n * @param {number} maxCallbacks\n * @returns {function} A function to cancel the listener\n */\nexport function EventsOnMultiple(eventName, callback, maxCallbacks) {\n    eventListeners[eventName] = eventListeners[eventName] || [];\n    const thisListener = new Listener(eventName, callback, maxCallbacks);\n    eventListeners[eventName].push(thisListener);\n    return () => listenerOff(thisListener);\n}\n\n/**\n * Registers an event listener that will be invoked every time the event is emitted\n *\n * @export\n * @param {string} eventName\n * @param {function} callback\n * @returns {function} A function to cancel the listener\n */\nexport function EventsOn(eventName, callback) {\n    return EventsOnMultiple(eventName, callback, -1);\n}\n\n/**\n * Registers an event listener that will be invoked once then destroyed\n *\n * @export\n * @param {string} eventName\n * @param {function} callback\n * @returns {function} A function to cancel the listener\n */\nexport function EventsOnce(eventName, callback) {\n    return EventsOnMultiple(eventName, callback, 1);\n}\n\nfunction notifyListeners(eventData) {\n\n    // Get the event name\n    let eventName = eventData.name;\n\n    // Check if we have any listeners for this event\n    if (eventListeners[eventName]) {\n\n        // Keep a list of listener indexes to destroy\n        const newEventListenerList = eventListeners[eventName].slice();\n\n        // Iterate listeners\n        for (let count = eventListeners[eventName].length - 1; count >= 0; count -= 1) {\n\n            // Get next listener\n            const listener = eventListeners[eventName][count];\n\n            let data = eventData.data;\n\n            // Do the callback\n            const destroy = listener.Callback(data);\n            if (destroy) {\n                // if the listener indicated to destroy itself, add it to the destroy list\n                newEventListenerList.splice(count, 1);\n            }\n        }\n\n        // Update callbacks with new list of listeners\n        if (newEventListenerList.length === 0) {\n            removeListener(eventName);\n        } else {\n            eventListeners[eventName] = newEventListenerList;\n        }\n    }\n}\n\n/**\n * Notify informs frontend listeners that an event was emitted with the given data\n *\n * @export\n * @param {string} notifyMessage - encoded notification message\n\n */\nexport function EventsNotify(notifyMessage) {\n    // Parse the message\n    let message;\n    try {\n        message = JSON.parse(notifyMessage);\n    } catch (e) {\n        const error = 'Invalid JSON passed to Notify: ' + notifyMessage;\n        throw new Error(error);\n    }\n    notifyListeners(message);\n}\n\n/**\n * Emit an event with the given name and data\n *\n * @export\n * @param {string} eventName\n */\nexport function EventsEmit(eventName) {\n\n    const payload = {\n        name: eventName,\n        data: [].slice.apply(arguments).slice(1),\n    };\n\n    // Notify JS listeners\n    notifyListeners(payload);\n\n    // Notify Go listeners\n    window.WailsInvoke('EE' + JSON.stringify(payload));\n}\n\nfunction removeListener(eventName) {\n    // Remove local listeners\n    delete eventListeners[eventName];\n\n    // Notify Go listeners\n    window.WailsInvoke('EX' + eventName);\n}\n\n/**\n * Off unregisters a listener previously registered with On,\n * optionally multiple listeneres can be unregistered via `additionalEventNames`\n *\n * @param {string} eventName\n * @param  {...string} additionalEventNames\n */\nexport function EventsOff(eventName, ...additionalEventNames) {\n    removeListener(eventName)\n\n    if (additionalEventNames.length > 0) {\n        additionalEventNames.forEach(eventName => {\n            removeListener(eventName)\n        })\n    }\n}\n\n/**\n * Off unregisters all event listeners previously registered with On\n */\n export function EventsOffAll() {\n    const eventNames = Object.keys(eventListeners);\n    for (let i = 0; i !== eventNames.length; i++) {\n        removeListener(eventNames[i]);\n    }\n}\n\n/**\n * listenerOff unregisters a listener previously registered with EventsOn\n *\n * @param {Listener} listener\n */\n function listenerOff(listener) {\n    const eventName = listener.eventName;\n    // Remove local listener\n    eventListeners[eventName] = eventListeners[eventName].filter(l => l !== listener);\n\n    // Clean up if there are no event listeners left\n    if (eventListeners[eventName].length === 0) {\n        removeListener(eventName);\n    }\n}\n", "/*\n _       __      _ __\n| |     / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n/* jshint esversion: 6 */\n\nexport const callbacks = {};\n\n/**\n * Returns a number from the native browser random function\n *\n * @returns number\n */\nfunction cryptoRandom() {\n\tvar array = new Uint32Array(1);\n\treturn window.crypto.getRandomValues(array)[0];\n}\n\n/**\n * Returns a number using da old-skool Math.Random\n * I likes to call it LOLRandom\n *\n * @returns number\n */\nfunction basicRandom() {\n\treturn Math.random() * 9007199254740991;\n}\n\n// Pick a random number function based on browser capability\nvar randomFunc;\nif (window.crypto) {\n\trandomFunc = cryptoRandom;\n} else {\n\trandomFunc = basicRandom;\n}\n\n\n/**\n * Call sends a message to the backend to call the binding with the\n * given data. A promise is returned and will be completed when the\n * backend responds. This will be resolved when the call was successful\n * or rejected if an error is passed back.\n * There is a timeout mechanism. If the call doesn't respond in the given\n * time (in milliseconds) then the promise is rejected.\n *\n * @export\n * @param {string} name\n * @param {any=} args\n * @param {number=} timeout\n * @returns\n */\nexport function Call(name, args, timeout) {\n\n\t// Timeout infinite by default\n\tif (timeout == null) {\n\t\ttimeout = 0;\n\t}\n\n\t// Create a promise\n\treturn new Promise(function (resolve, reject) {\n\n\t\t// Create a unique callbackID\n\t\tvar callbackID;\n\t\tdo {\n\t\t\tcallbackID = name + '-' + randomFunc();\n\t\t} while (callbacks[callbackID]);\n\n\t\tvar timeoutHandle;\n\t\t// Set timeout\n\t\tif (timeout > 0) {\n\t\t\ttimeoutHandle = setTimeout(function () {\n\t\t\t\treject(Error('Call to ' + name + ' timed out. Request ID: ' + callbackID));\n\t\t\t}, timeout);\n\t\t}\n\n\t\t// Store callback\n\t\tcallbacks[callbackID] = {\n\t\t\ttimeoutHandle: timeoutHandle,\n\t\t\treject: reject,\n\t\t\tresolve: resolve\n\t\t};\n\n\t\ttry {\n\t\t\tconst payload = {\n\t\t\t\tname,\n\t\t\t\targs,\n\t\t\t\tcallbackID,\n\t\t\t};\n\n            // Make the call\n            window.WailsInvoke('C' + JSON.stringify(payload));\n        } catch (e) {\n            // eslint-disable-next-line\n            console.error(e);\n        }\n    });\n}\n\nwindow.ObfuscatedCall = (id, args, timeout) => {\n\n    // Timeout infinite by default\n    if (timeout == null) {\n        timeout = 0;\n    }\n\n    // Create a promise\n    return new Promise(function (resolve, reject) {\n\n        // Create a unique callbackID\n        var callbackID;\n        do {\n            callbackID = id + '-' + randomFunc();\n        } while (callbacks[callbackID]);\n\n        var timeoutHandle;\n        // Set timeout\n        if (timeout > 0) {\n            timeoutHandle = setTimeout(function () {\n                reject(Error('Call to method ' + id + ' timed out. Request ID: ' + callbackID));\n            }, timeout);\n        }\n\n        // Store callback\n        callbacks[callbackID] = {\n            timeoutHandle: timeoutHandle,\n            reject: reject,\n            resolve: resolve\n        };\n\n        try {\n            const payload = {\n\t\t\t\tid,\n\t\t\t\targs,\n\t\t\t\tcallbackID,\n\t\t\t};\n\n            // Make the call\n            window.WailsInvoke('c' + JSON.stringify(payload));\n        } catch (e) {\n            // eslint-disable-next-line\n            console.error(e);\n        }\n    });\n};\n\n\n/**\n * Called by the backend to return data to a previously called\n * binding invocation\n *\n * @export\n * @param {string} incomingMessage\n */\nexport function Callback(incomingMessage) {\n\t// Parse the message\n\tlet message;\n\ttry {\n\t\tmessage = JSON.parse(incomingMessage);\n\t} catch (e) {\n\t\tconst error = `Invalid JSON passed to callback: ${e.message}. Message: ${incomingMessage}`;\n\t\truntime.LogDebug(error);\n\t\tthrow new Error(error);\n\t}\n\tlet callbackID = message.callbackid;\n\tlet callbackData = callbacks[callbackID];\n\tif (!callbackData) {\n\t\tconst error = `Callback '${callbackID}' not registered!!!`;\n\t\tconsole.error(error); // eslint-disable-line\n\t\tthrow new Error(error);\n\t}\n\tclearTimeout(callbackData.timeoutHandle);\n\n\tdelete callbacks[callbackID];\n\n\tif (message.error) {\n\t\tcallbackData.reject(message.error);\n\t} else {\n\t\tcallbackData.resolve(message.result);\n\t}\n}\n", "/*\n _       __      _ __    \n| |     / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  ) \n|__/|__/\\__,_/_/_/____/  \nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n/* jshint esversion: 6 */\n\nimport {Call} from './calls';\n\n// This is where we bind go method wrappers\nwindow.go = {};\n\nexport function SetBindings(bindingsMap) {\n\ttry {\n\t\tbindingsMap = JSON.parse(bindingsMap);\n\t} catch (e) {\n\t\tconsole.error(e);\n\t}\n\n\t// Initialise the bindings map\n\twindow.go = window.go || {};\n\n\t// Iterate package names\n\tObject.keys(bindingsMap).forEach((packageName) => {\n\n\t\t// Create inner map if it doesn't exist\n\t\twindow.go[packageName] = window.go[packageName] || {};\n\n\t\t// Iterate struct names\n\t\tObject.keys(bindingsMap[packageName]).forEach((structName) => {\n\n\t\t\t// Create inner map if it doesn't exist\n\t\t\twindow.go[packageName][structName] = window.go[packageName][structName] || {};\n\n\t\t\tObject.keys(bindingsMap[packageName][structName]).forEach((methodName) => {\n\n\t\t\t\twindow.go[packageName][structName][methodName] = function () {\n\n\t\t\t\t\t// No timeout by default\n\t\t\t\t\tlet timeout = 0;\n\n\t\t\t\t\t// Actual function\n\t\t\t\t\tfunction dynamic() {\n\t\t\t\t\t\tconst args = [].slice.call(arguments);\n\t\t\t\t\t\treturn Call([packageName, structName, methodName].join('.'), args, timeout);\n\t\t\t\t\t}\n\n\t\t\t\t\t// Allow setting timeout to function\n\t\t\t\t\tdynamic.setTimeout = function (newTimeout) {\n\t\t\t\t\t\ttimeout = newTimeout;\n\t\t\t\t\t};\n\n\t\t\t\t\t// Allow getting timeout to function\n\t\t\t\t\tdynamic.getTimeout = function () {\n\t\t\t\t\t\treturn timeout;\n\t\t\t\t\t};\n\n\t\t\t\t\treturn dynamic;\n\t\t\t\t}();\n\t\t\t});\n\t\t});\n\t});\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\n\nimport {Call} from \"./calls\";\n\nexport function WindowReload() {\n    window.location.reload();\n}\n\nexport function WindowReloadApp() {\n    window.WailsInvoke('WR');\n}\n\nexport function WindowSetSystemDefaultTheme() {\n    window.WailsInvoke('WASDT');\n}\n\nexport function WindowSetLightTheme() {\n    window.WailsInvoke('WALT');\n}\n\nexport function WindowSetDarkTheme() {\n    window.WailsInvoke('WADT');\n}\n\n/**\n * Place the window in the center of the screen\n *\n * @export\n */\nexport function WindowCenter() {\n    window.WailsInvoke('Wc');\n}\n\n/**\n * Sets the window title\n *\n * @param {string} title\n * @export\n */\nexport function WindowSetTitle(title) {\n    window.WailsInvoke('WT' + title);\n}\n\n/**\n * Makes the window go fullscreen\n *\n * @export\n */\nexport function WindowFullscreen() {\n    window.WailsInvoke('WF');\n}\n\n/**\n * Reverts the window from fullscreen\n *\n * @export\n */\nexport function WindowUnfullscreen() {\n    window.WailsInvoke('Wf');\n}\n\n/**\n * Returns the state of the window, i.e. whether the window is in full screen mode or not.\n *\n * @export\n * @return {Promise<boolean>} The state of the window\n */\nexport function WindowIsFullscreen() {\n    return Call(\":wails:WindowIsFullscreen\");\n}\n\n/**\n * Set the Size of the window\n *\n * @export\n * @param {number} width\n * @param {number} height\n */\nexport function WindowSetSize(width, height) {\n    window.WailsInvoke('Ws:' + width + ':' + height);\n}\n\n/**\n * Get the Size of the window\n *\n * @export\n * @return {Promise<{w: number, h: number}>} The size of the window\n\n */\nexport function WindowGetSize() {\n    return Call(\":wails:WindowGetSize\");\n}\n\n/**\n * Set the maximum size of the window\n *\n * @export\n * @param {number} width\n * @param {number} height\n */\nexport function WindowSetMaxSize(width, height) {\n    window.WailsInvoke('WZ:' + width + ':' + height);\n}\n\n/**\n * Set the minimum size of the window\n *\n * @export\n * @param {number} width\n * @param {number} height\n */\nexport function WindowSetMinSize(width, height) {\n    window.WailsInvoke('Wz:' + width + ':' + height);\n}\n\n\n\n/**\n * Set the window AlwaysOnTop or not on top\n *\n * @export\n */\nexport function WindowSetAlwaysOnTop(b) {\n\n    window.WailsInvoke('WATP:' + (b ? '1' : '0'));\n}\n\n\n\n\n/**\n * Set the Position of the window\n *\n * @export\n * @param {number} x\n * @param {number} y\n */\nexport function WindowSetPosition(x, y) {\n    window.WailsInvoke('Wp:' + x + ':' + y);\n}\n\n/**\n * Get the Position of the window\n *\n * @export\n * @return {Promise<{x: number, y: number}>} The position of the window\n */\nexport function WindowGetPosition() {\n    return Call(\":wails:WindowGetPos\");\n}\n\n/**\n * Hide the Window\n *\n * @export\n */\nexport function WindowHide() {\n    window.WailsInvoke('WH');\n}\n\n/**\n * Show the Window\n *\n * @export\n */\nexport function WindowShow() {\n    window.WailsInvoke('WS');\n}\n\n/**\n * Maximise the Window\n *\n * @export\n */\nexport function WindowMaximise() {\n    window.WailsInvoke('WM');\n}\n\n/**\n * Toggle the Maximise of the Window\n *\n * @export\n */\nexport function WindowToggleMaximise() {\n    window.WailsInvoke('Wt');\n}\n\n/**\n * Unmaximise the Window\n *\n * @export\n */\nexport function WindowUnmaximise() {\n    window.WailsInvoke('WU');\n}\n\n/**\n * Returns the state of the window, i.e. whether the window is maximised or not.\n *\n * @export\n * @return {Promise<boolean>} The state of the window\n */\nexport function WindowIsMaximised() {\n    return Call(\":wails:WindowIsMaximised\");\n}\n\n/**\n * Minimise the Window\n *\n * @export\n */\nexport function WindowMinimise() {\n    window.WailsInvoke('Wm');\n}\n\n/**\n * Unminimise the Window\n *\n * @export\n */\nexport function WindowUnminimise() {\n    window.WailsInvoke('Wu');\n}\n\n/**\n * Returns the state of the window, i.e. whether the window is minimised or not.\n *\n * @export\n * @return {Promise<boolean>} The state of the window\n */\nexport function WindowIsMinimised() {\n    return Call(\":wails:WindowIsMinimised\");\n}\n\n/**\n * Returns the state of the window, i.e. whether the window is normal or not.\n *\n * @export\n * @return {Promise<boolean>} The state of the window\n */\nexport function WindowIsNormal() {\n    return Call(\":wails:WindowIsNormal\");\n}\n\n/**\n * Sets the background colour of the window\n *\n * @export\n * @param {number} R Red\n * @param {number} G Green\n * @param {number} B Blue\n * @param {number} A Alpha\n */\nexport function WindowSetBackgroundColour(R, G, B, A) {\n    let rgba = JSON.stringify({r: R || 0, g: G || 0, b: B || 0, a: A || 255});\n    window.WailsInvoke('Wr:' + rgba);\n}\n\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\n\nimport {Call} from \"./calls\";\n\n\n/**\n * Gets the all screens. Call this anew each time you want to refresh data from the underlying windowing system.\n * @export\n * @typedef {import('../wrapper/runtime').Screen} Screen\n * @return {Promise<{Screen[]}>} The screens\n */\nexport function ScreenGetAll() {\n    return Call(\":wails:ScreenGetAll\");\n}\n", "/**\n * @description: Use the system default browser to open the url\n * @param {string} url \n * @return {void}\n */\nexport function BrowserOpenURL(url) {\n  window.WailsInvoke('BO:' + url);\n}", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\nimport {Call} from \"./calls\";\n\n/**\n * Set the Size of the window\n *\n * @export\n * @param {string} text\n */\nexport function ClipboardSetText(text) {\n    return Call(\":wails:ClipboardSetText\", [text]);\n}\n\n/**\n * Get the text content of the clipboard\n *\n * @export\n * @return {Promise<{string}>} Text content of the clipboard\n\n */\nexport function ClipboardGetText() {\n    return Call(\":wails:ClipboardGetText\");\n}", "/*\n--default-contextmenu: auto; (default) will show the default context menu if contentEditable is true OR text has been selected OR element is input or textarea\n--default-contextmenu: show; will always show the default context menu\n--default-contextmenu: hide; will always hide the default context menu\n\nThis rule is inherited like normal CSS rules, so nesting works as expected\n*/\nexport function processDefaultContextMenu(event) {\n    // Process default context menu\n    const element = event.target;\n    const computedStyle = window.getComputedStyle(element);\n    const defaultContextMenuAction = computedStyle.getPropertyValue(\"--default-contextmenu\").trim();\n    switch (defaultContextMenuAction) {\n        case \"show\":\n            return;\n        case \"hide\":\n            event.preventDefault();\n            return;\n        default:\n            // Check if contentEditable is true\n            if (element.isContentEditable) {\n                return;\n            }\n\n            // Check if text has been selected and action is on the selected elements\n            const selection = window.getSelection();\n            const hasSelection = (selection.toString().length > 0)\n            if (hasSelection) {\n                for (let i = 0; i < selection.rangeCount; i++) {\n                    const range = selection.getRangeAt(i);\n                    const rects = range.getClientRects();\n                    for (let j = 0; j < rects.length; j++) {\n                        const rect = rects[j];\n                        if (document.elementFromPoint(rect.left, rect.top) === element) {\n                            return;\n                        }\n                    }\n                }\n            }\n            // Check if tagname is input or textarea\n            if (element.tagName === \"INPUT\" || element.tagName === \"TEXTAREA\") {\n                if (hasSelection || (!element.readOnly && !element.disabled)) {\n                    return;\n                }\n            }\n\n            // hide default context menu\n            event.preventDefault();\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n/* jshint esversion: 9 */\nimport * as Log from './log';\nimport {eventListeners, EventsEmit, EventsNotify, EventsOff, EventsOn, EventsOnce, EventsOnMultiple} from './events';\nimport {Call, Callback, callbacks} from './calls';\nimport {SetBindings} from \"./bindings\";\nimport * as Window from \"./window\";\nimport * as Screen from \"./screen\";\nimport * as Browser from \"./browser\";\nimport * as Clipboard from \"./clipboard\";\nimport * as ContextMenu from \"./contextmenu\";\n\n\nexport function Quit() {\n    window.WailsInvoke('Q');\n}\n\nexport function Show() {\n    window.WailsInvoke('S');\n}\n\nexport function Hide() {\n    window.WailsInvoke('H');\n}\n\nexport function Environment() {\n    return Call(\":wails:Environment\");\n}\n\n// The JS runtime\nwindow.runtime = {\n    ...Log,\n    ...Window,\n    ...Browser,\n    ...Screen,\n    ...Clipboard,\n    EventsOn,\n    EventsOnce,\n    EventsOnMultiple,\n    EventsEmit,\n    EventsOff,\n    Environment,\n    Show,\n    Hide,\n    Quit\n};\n\n// Internal wails endpoints\nwindow.wails = {\n    Callback,\n    EventsNotify,\n    SetBindings,\n    eventListeners,\n    callbacks,\n    flags: {\n        disableScrollbarDrag: false,\n        disableDefaultContextMenu: false,\n        enableResize: false,\n        defaultCursor: null,\n        borderThickness: 6,\n        shouldDrag: false,\n        deferDragToMouseMove: true,\n        cssDragProperty: \"--wails-draggable\",\n        cssDragValue: \"drag\",\n    }\n};\n\n// Set the bindings\nif (window.wailsbindings) {\n    window.wails.SetBindings(window.wailsbindings);\n    delete window.wails.SetBindings;\n}\n\n// (bool) This is evaluated at build time in package.json\nif (!DEBUG) {\n    delete window.wailsbindings;\n}\n\nlet dragTest = function (e) {\n    var val = window.getComputedStyle(e.target).getPropertyValue(window.wails.flags.cssDragProperty);\n    if (val) {\n      val = val.trim();\n    }\n    \n    if (val !== window.wails.flags.cssDragValue) {\n        return false;\n    }\n\n    if (e.buttons !== 1) {\n        // Do not start dragging if not the primary button has been clicked.\n        return false;\n    }\n\n    if (e.detail !== 1) {\n        // Do not start dragging if more than once has been clicked, e.g. when double clicking\n        return false;\n    }\n\n    return true;\n};\n\nwindow.wails.setCSSDragProperties = function (property, value) {\n    window.wails.flags.cssDragProperty = property;\n    window.wails.flags.cssDragValue = value;\n}\n\nwindow.addEventListener('mousedown', (e) => {\n\n    // Check for resizing\n    if (window.wails.flags.resizeEdge) {\n        window.WailsInvoke(\"resize:\" + window.wails.flags.resizeEdge);\n        e.preventDefault();\n        return;\n    }\n\n    if (dragTest(e)) {\n        if (window.wails.flags.disableScrollbarDrag) {\n            // This checks for clicks on the scroll bar\n            if (e.offsetX > e.target.clientWidth || e.offsetY > e.target.clientHeight) {\n                return;\n            }\n        }\n        if (window.wails.flags.deferDragToMouseMove) {\n            window.wails.flags.shouldDrag = true;\n        } else {\n            e.preventDefault()\n            window.WailsInvoke(\"drag\");\n        }\n        return;\n    } else {\n        window.wails.flags.shouldDrag = false;\n    }\n});\n\nwindow.addEventListener('mouseup', () => {\n    window.wails.flags.shouldDrag = false;\n});\n\nfunction setResize(cursor) {\n    document.documentElement.style.cursor = cursor || window.wails.flags.defaultCursor;\n    window.wails.flags.resizeEdge = cursor;\n}\n\nwindow.addEventListener('mousemove', function (e) {\n    if (window.wails.flags.shouldDrag) {\n        window.wails.flags.shouldDrag = false;\n        let mousePressed = e.buttons !== undefined ? e.buttons : e.which;\n        if (mousePressed > 0) {\n            window.WailsInvoke(\"drag\");\n            return;\n        }\n    }\n    if (!window.wails.flags.enableResize) {\n        return;\n    }\n    if (window.wails.flags.defaultCursor == null) {\n        window.wails.flags.defaultCursor = document.documentElement.style.cursor;\n    }\n    if (window.outerWidth - e.clientX < window.wails.flags.borderThickness && window.outerHeight - e.clientY < window.wails.flags.borderThickness) {\n        document.documentElement.style.cursor = \"se-resize\";\n    }\n    let rightBorder = window.outerWidth - e.clientX < window.wails.flags.borderThickness;\n    let leftBorder = e.clientX < window.wails.flags.borderThickness;\n    let topBorder = e.clientY < window.wails.flags.borderThickness;\n    let bottomBorder = window.outerHeight - e.clientY < window.wails.flags.borderThickness;\n\n    // If we aren't on an edge, but were, reset the cursor to default\n    if (!leftBorder && !rightBorder && !topBorder && !bottomBorder && window.wails.flags.resizeEdge !== undefined) {\n        setResize();\n    } else if (rightBorder && bottomBorder) setResize(\"se-resize\");\n    else if (leftBorder && bottomBorder) setResize(\"sw-resize\");\n    else if (leftBorder && topBorder) setResize(\"nw-resize\");\n    else if (topBorder && rightBorder) setResize(\"ne-resize\");\n    else if (leftBorder) setResize(\"w-resize\");\n    else if (topBorder) setResize(\"n-resize\");\n    else if (bottomBorder) setResize(\"s-resize\");\n    else if (rightBorder) setResize(\"e-resize\");\n\n});\n\n// Setup context menu hook\nwindow.addEventListener('contextmenu', function (e) {\n    // always show the contextmenu in debug & dev\n    if (DEBUG) return;\n\n    if (window.wails.flags.disableDefaultContextMenu) {\n        e.preventDefault();\n    } else {\n        ContextMenu.processDefaultContextMenu(e);\n    }\n});\n\nwindow.WailsInvoke(\"runtime:ready\");"],
  "mappings": "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",
  "names": ["eventName"]
}
 +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["desktop/log.js", "desktop/events.js", "desktop/calls.js", "desktop/bindings.js", "desktop/window.js", "desktop/screen.js", "desktop/browser.js", "desktop/clipboard.js", "desktop/draganddrop.js", "desktop/contextmenu.js", "desktop/main.js"],
  "sourcesContent": ["/*\n _       __      _ __\n| |     / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 6 */\n\n/**\n * Sends a log message to the backend with the given level + message\n *\n * @param {string} level\n * @param {string} message\n */\nfunction sendLogMessage(level, message) {\n\n\t// Log Message format:\n\t// l[type][message]\n\twindow.WailsInvoke('L' + level + message);\n}\n\n/**\n * Log the given trace message with the backend\n *\n * @export\n * @param {string} message\n */\nexport function LogTrace(message) {\n\tsendLogMessage('T', message);\n}\n\n/**\n * Log the given message with the backend\n *\n * @export\n * @param {string} message\n */\nexport function LogPrint(message) {\n\tsendLogMessage('P', message);\n}\n\n/**\n * Log the given debug message with the backend\n *\n * @export\n * @param {string} message\n */\nexport function LogDebug(message) {\n\tsendLogMessage('D', message);\n}\n\n/**\n * Log the given info message with the backend\n *\n * @export\n * @param {string} message\n */\nexport function LogInfo(message) {\n\tsendLogMessage('I', message);\n}\n\n/**\n * Log the given warning message with the backend\n *\n * @export\n * @param {string} message\n */\nexport function LogWarning(message) {\n\tsendLogMessage('W', message);\n}\n\n/**\n * Log the given error message with the backend\n *\n * @export\n * @param {string} message\n */\nexport function LogError(message) {\n\tsendLogMessage('E', message);\n}\n\n/**\n * Log the given fatal message with the backend\n *\n * @export\n * @param {string} message\n */\nexport function LogFatal(message) {\n\tsendLogMessage('F', message);\n}\n\n/**\n * Sets the Log level to the given log level\n *\n * @export\n * @param {number} loglevel\n */\nexport function SetLogLevel(loglevel) {\n\tsendLogMessage('S', loglevel);\n}\n\n// Log levels\nexport const LogLevel = {\n\tTRACE: 1,\n\tDEBUG: 2,\n\tINFO: 3,\n\tWARNING: 4,\n\tERROR: 5,\n};\n", "/*\n _       __      _ __\n| |     / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n/* jshint esversion: 6 */\n\n// Defines a single listener with a maximum number of times to callback\n\n/**\n * The Listener class defines a listener! :-)\n *\n * @class Listener\n */\nclass Listener {\n    /**\n     * Creates an instance of Listener.\n     * @param {string} eventName\n     * @param {function} callback\n     * @param {number} maxCallbacks\n     * @memberof Listener\n     */\n    constructor(eventName, callback, maxCallbacks) {\n        this.eventName = eventName;\n        // Default of -1 means infinite\n        this.maxCallbacks = maxCallbacks || -1;\n        // Callback invokes the callback with the given data\n        // Returns true if this listener should be destroyed\n        this.Callback = (data) => {\n            callback.apply(null, data);\n            // If maxCallbacks is infinite, return false (do not destroy)\n            if (this.maxCallbacks === -1) {\n                return false;\n            }\n            // Decrement maxCallbacks. Return true if now 0, otherwise false\n            this.maxCallbacks -= 1;\n            return this.maxCallbacks === 0;\n        };\n    }\n}\n\nexport const eventListeners = {};\n\n/**\n * Registers an event listener that will be invoked `maxCallbacks` times before being destroyed\n *\n * @export\n * @param {string} eventName\n * @param {function} callback\n * @param {number} maxCallbacks\n * @returns {function} A function to cancel the listener\n */\nexport function EventsOnMultiple(eventName, callback, maxCallbacks) {\n    eventListeners[eventName] = eventListeners[eventName] || [];\n    const thisListener = new Listener(eventName, callback, maxCallbacks);\n    eventListeners[eventName].push(thisListener);\n    return () => listenerOff(thisListener);\n}\n\n/**\n * Registers an event listener that will be invoked every time the event is emitted\n *\n * @export\n * @param {string} eventName\n * @param {function} callback\n * @returns {function} A function to cancel the listener\n */\nexport function EventsOn(eventName, callback) {\n    return EventsOnMultiple(eventName, callback, -1);\n}\n\n/**\n * Registers an event listener that will be invoked once then destroyed\n *\n * @export\n * @param {string} eventName\n * @param {function} callback\n * @returns {function} A function to cancel the listener\n */\nexport function EventsOnce(eventName, callback) {\n    return EventsOnMultiple(eventName, callback, 1);\n}\n\nfunction notifyListeners(eventData) {\n\n    // Get the event name\n    let eventName = eventData.name;\n\n    // Check if we have any listeners for this event\n    if (eventListeners[eventName]) {\n\n        // Keep a list of listener indexes to destroy\n        const newEventListenerList = eventListeners[eventName].slice();\n\n        // Iterate listeners\n        for (let count = eventListeners[eventName].length - 1; count >= 0; count -= 1) {\n\n            // Get next listener\n            const listener = eventListeners[eventName][count];\n\n            let data = eventData.data;\n\n            // Do the callback\n            const destroy = listener.Callback(data);\n            if (destroy) {\n                // if the listener indicated to destroy itself, add it to the destroy list\n                newEventListenerList.splice(count, 1);\n            }\n        }\n\n        // Update callbacks with new list of listeners\n        if (newEventListenerList.length === 0) {\n            removeListener(eventName);\n        } else {\n            eventListeners[eventName] = newEventListenerList;\n        }\n    }\n}\n\n/**\n * Notify informs frontend listeners that an event was emitted with the given data\n *\n * @export\n * @param {string} notifyMessage - encoded notification message\n\n */\nexport function EventsNotify(notifyMessage) {\n    // Parse the message\n    let message;\n    try {\n        message = JSON.parse(notifyMessage);\n    } catch (e) {\n        const error = 'Invalid JSON passed to Notify: ' + notifyMessage;\n        throw new Error(error);\n    }\n    notifyListeners(message);\n}\n\n/**\n * Emit an event with the given name and data\n *\n * @export\n * @param {string} eventName\n */\nexport function EventsEmit(eventName) {\n\n    const payload = {\n        name: eventName,\n        data: [].slice.apply(arguments).slice(1),\n    };\n\n    // Notify JS listeners\n    notifyListeners(payload);\n\n    // Notify Go listeners\n    window.WailsInvoke('EE' + JSON.stringify(payload));\n}\n\nfunction removeListener(eventName) {\n    // Remove local listeners\n    delete eventListeners[eventName];\n\n    // Notify Go listeners\n    window.WailsInvoke('EX' + eventName);\n}\n\n/**\n * Off unregisters a listener previously registered with On,\n * optionally multiple listeneres can be unregistered via `additionalEventNames`\n *\n * @param {string} eventName\n * @param  {...string} additionalEventNames\n */\nexport function EventsOff(eventName, ...additionalEventNames) {\n    removeListener(eventName)\n\n    if (additionalEventNames.length > 0) {\n        additionalEventNames.forEach(eventName => {\n            removeListener(eventName)\n        })\n    }\n}\n\n/**\n * Off unregisters all event listeners previously registered with On\n */\n export function EventsOffAll() {\n    const eventNames = Object.keys(eventListeners);\n    for (let i = 0; i !== eventNames.length; i++) {\n        removeListener(eventNames[i]);\n    }\n}\n\n/**\n * listenerOff unregisters a listener previously registered with EventsOn\n *\n * @param {Listener} listener\n */\n function listenerOff(listener) {\n    const eventName = listener.eventName;\n    // Remove local listener\n    eventListeners[eventName] = eventListeners[eventName].filter(l => l !== listener);\n\n    // Clean up if there are no event listeners left\n    if (eventListeners[eventName].length === 0) {\n        removeListener(eventName);\n    }\n}\n", "/*\n _       __      _ __\n| |     / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n/* jshint esversion: 6 */\n\nexport const callbacks = {};\n\n/**\n * Returns a number from the native browser random function\n *\n * @returns number\n */\nfunction cryptoRandom() {\n\tvar array = new Uint32Array(1);\n\treturn window.crypto.getRandomValues(array)[0];\n}\n\n/**\n * Returns a number using da old-skool Math.Random\n * I likes to call it LOLRandom\n *\n * @returns number\n */\nfunction basicRandom() {\n\treturn Math.random() * 9007199254740991;\n}\n\n// Pick a random number function based on browser capability\nvar randomFunc;\nif (window.crypto) {\n\trandomFunc = cryptoRandom;\n} else {\n\trandomFunc = basicRandom;\n}\n\n\n/**\n * Call sends a message to the backend to call the binding with the\n * given data. A promise is returned and will be completed when the\n * backend responds. This will be resolved when the call was successful\n * or rejected if an error is passed back.\n * There is a timeout mechanism. If the call doesn't respond in the given\n * time (in milliseconds) then the promise is rejected.\n *\n * @export\n * @param {string} name\n * @param {any=} args\n * @param {number=} timeout\n * @returns\n */\nexport function Call(name, args, timeout) {\n\n\t// Timeout infinite by default\n\tif (timeout == null) {\n\t\ttimeout = 0;\n\t}\n\n\t// Create a promise\n\treturn new Promise(function (resolve, reject) {\n\n\t\t// Create a unique callbackID\n\t\tvar callbackID;\n\t\tdo {\n\t\t\tcallbackID = name + '-' + randomFunc();\n\t\t} while (callbacks[callbackID]);\n\n\t\tvar timeoutHandle;\n\t\t// Set timeout\n\t\tif (timeout > 0) {\n\t\t\ttimeoutHandle = setTimeout(function () {\n\t\t\t\treject(Error('Call to ' + name + ' timed out. Request ID: ' + callbackID));\n\t\t\t}, timeout);\n\t\t}\n\n\t\t// Store callback\n\t\tcallbacks[callbackID] = {\n\t\t\ttimeoutHandle: timeoutHandle,\n\t\t\treject: reject,\n\t\t\tresolve: resolve\n\t\t};\n\n\t\ttry {\n\t\t\tconst payload = {\n\t\t\t\tname,\n\t\t\t\targs,\n\t\t\t\tcallbackID,\n\t\t\t};\n\n            // Make the call\n            window.WailsInvoke('C' + JSON.stringify(payload));\n        } catch (e) {\n            // eslint-disable-next-line\n            console.error(e);\n        }\n    });\n}\n\nwindow.ObfuscatedCall = (id, args, timeout) => {\n\n    // Timeout infinite by default\n    if (timeout == null) {\n        timeout = 0;\n    }\n\n    // Create a promise\n    return new Promise(function (resolve, reject) {\n\n        // Create a unique callbackID\n        var callbackID;\n        do {\n            callbackID = id + '-' + randomFunc();\n        } while (callbacks[callbackID]);\n\n        var timeoutHandle;\n        // Set timeout\n        if (timeout > 0) {\n            timeoutHandle = setTimeout(function () {\n                reject(Error('Call to method ' + id + ' timed out. Request ID: ' + callbackID));\n            }, timeout);\n        }\n\n        // Store callback\n        callbacks[callbackID] = {\n            timeoutHandle: timeoutHandle,\n            reject: reject,\n            resolve: resolve\n        };\n\n        try {\n            const payload = {\n\t\t\t\tid,\n\t\t\t\targs,\n\t\t\t\tcallbackID,\n\t\t\t};\n\n            // Make the call\n            window.WailsInvoke('c' + JSON.stringify(payload));\n        } catch (e) {\n            // eslint-disable-next-line\n            console.error(e);\n        }\n    });\n};\n\n\n/**\n * Called by the backend to return data to a previously called\n * binding invocation\n *\n * @export\n * @param {string} incomingMessage\n */\nexport function Callback(incomingMessage) {\n\t// Parse the message\n\tlet message;\n\ttry {\n\t\tmessage = JSON.parse(incomingMessage);\n\t} catch (e) {\n\t\tconst error = `Invalid JSON passed to callback: ${e.message}. Message: ${incomingMessage}`;\n\t\truntime.LogDebug(error);\n\t\tthrow new Error(error);\n\t}\n\tlet callbackID = message.callbackid;\n\tlet callbackData = callbacks[callbackID];\n\tif (!callbackData) {\n\t\tconst error = `Callback '${callbackID}' not registered!!!`;\n\t\tconsole.error(error); // eslint-disable-line\n\t\tthrow new Error(error);\n\t}\n\tclearTimeout(callbackData.timeoutHandle);\n\n\tdelete callbacks[callbackID];\n\n\tif (message.error) {\n\t\tcallbackData.reject(message.error);\n\t} else {\n\t\tcallbackData.resolve(message.result);\n\t}\n}\n", "/*\n _       __      _ __    \n| |     / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  ) \n|__/|__/\\__,_/_/_/____/  \nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n/* jshint esversion: 6 */\n\nimport {Call} from './calls';\n\n// This is where we bind go method wrappers\nwindow.go = {};\n\nexport function SetBindings(bindingsMap) {\n\ttry {\n\t\tbindingsMap = JSON.parse(bindingsMap);\n\t} catch (e) {\n\t\tconsole.error(e);\n\t}\n\n\t// Initialise the bindings map\n\twindow.go = window.go || {};\n\n\t// Iterate package names\n\tObject.keys(bindingsMap).forEach((packageName) => {\n\n\t\t// Create inner map if it doesn't exist\n\t\twindow.go[packageName] = window.go[packageName] || {};\n\n\t\t// Iterate struct names\n\t\tObject.keys(bindingsMap[packageName]).forEach((structName) => {\n\n\t\t\t// Create inner map if it doesn't exist\n\t\t\twindow.go[packageName][structName] = window.go[packageName][structName] || {};\n\n\t\t\tObject.keys(bindingsMap[packageName][structName]).forEach((methodName) => {\n\n\t\t\t\twindow.go[packageName][structName][methodName] = function () {\n\n\t\t\t\t\t// No timeout by default\n\t\t\t\t\tlet timeout = 0;\n\n\t\t\t\t\t// Actual function\n\t\t\t\t\tfunction dynamic() {\n\t\t\t\t\t\tconst args = [].slice.call(arguments);\n\t\t\t\t\t\treturn Call([packageName, structName, methodName].join('.'), args, timeout);\n\t\t\t\t\t}\n\n\t\t\t\t\t// Allow setting timeout to function\n\t\t\t\t\tdynamic.setTimeout = function (newTimeout) {\n\t\t\t\t\t\ttimeout = newTimeout;\n\t\t\t\t\t};\n\n\t\t\t\t\t// Allow getting timeout to function\n\t\t\t\t\tdynamic.getTimeout = function () {\n\t\t\t\t\t\treturn timeout;\n\t\t\t\t\t};\n\n\t\t\t\t\treturn dynamic;\n\t\t\t\t}();\n\t\t\t});\n\t\t});\n\t});\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\n\nimport {Call} from \"./calls\";\n\nexport function WindowReload() {\n    window.location.reload();\n}\n\nexport function WindowReloadApp() {\n    window.WailsInvoke('WR');\n}\n\nexport function WindowSetSystemDefaultTheme() {\n    window.WailsInvoke('WASDT');\n}\n\nexport function WindowSetLightTheme() {\n    window.WailsInvoke('WALT');\n}\n\nexport function WindowSetDarkTheme() {\n    window.WailsInvoke('WADT');\n}\n\n/**\n * Place the window in the center of the screen\n *\n * @export\n */\nexport function WindowCenter() {\n    window.WailsInvoke('Wc');\n}\n\n/**\n * Sets the window title\n *\n * @param {string} title\n * @export\n */\nexport function WindowSetTitle(title) {\n    window.WailsInvoke('WT' + title);\n}\n\n/**\n * Makes the window go fullscreen\n *\n * @export\n */\nexport function WindowFullscreen() {\n    window.WailsInvoke('WF');\n}\n\n/**\n * Reverts the window from fullscreen\n *\n * @export\n */\nexport function WindowUnfullscreen() {\n    window.WailsInvoke('Wf');\n}\n\n/**\n * Returns the state of the window, i.e. whether the window is in full screen mode or not.\n *\n * @export\n * @return {Promise<boolean>} The state of the window\n */\nexport function WindowIsFullscreen() {\n    return Call(\":wails:WindowIsFullscreen\");\n}\n\n/**\n * Set the Size of the window\n *\n * @export\n * @param {number} width\n * @param {number} height\n */\nexport function WindowSetSize(width, height) {\n    window.WailsInvoke('Ws:' + width + ':' + height);\n}\n\n/**\n * Get the Size of the window\n *\n * @export\n * @return {Promise<{w: number, h: number}>} The size of the window\n\n */\nexport function WindowGetSize() {\n    return Call(\":wails:WindowGetSize\");\n}\n\n/**\n * Set the maximum size of the window\n *\n * @export\n * @param {number} width\n * @param {number} height\n */\nexport function WindowSetMaxSize(width, height) {\n    window.WailsInvoke('WZ:' + width + ':' + height);\n}\n\n/**\n * Set the minimum size of the window\n *\n * @export\n * @param {number} width\n * @param {number} height\n */\nexport function WindowSetMinSize(width, height) {\n    window.WailsInvoke('Wz:' + width + ':' + height);\n}\n\n\n\n/**\n * Set the window AlwaysOnTop or not on top\n *\n * @export\n */\nexport function WindowSetAlwaysOnTop(b) {\n\n    window.WailsInvoke('WATP:' + (b ? '1' : '0'));\n}\n\n\n\n\n/**\n * Set the Position of the window\n *\n * @export\n * @param {number} x\n * @param {number} y\n */\nexport function WindowSetPosition(x, y) {\n    window.WailsInvoke('Wp:' + x + ':' + y);\n}\n\n/**\n * Get the Position of the window\n *\n * @export\n * @return {Promise<{x: number, y: number}>} The position of the window\n */\nexport function WindowGetPosition() {\n    return Call(\":wails:WindowGetPos\");\n}\n\n/**\n * Hide the Window\n *\n * @export\n */\nexport function WindowHide() {\n    window.WailsInvoke('WH');\n}\n\n/**\n * Show the Window\n *\n * @export\n */\nexport function WindowShow() {\n    window.WailsInvoke('WS');\n}\n\n/**\n * Maximise the Window\n *\n * @export\n */\nexport function WindowMaximise() {\n    window.WailsInvoke('WM');\n}\n\n/**\n * Toggle the Maximise of the Window\n *\n * @export\n */\nexport function WindowToggleMaximise() {\n    window.WailsInvoke('Wt');\n}\n\n/**\n * Unmaximise the Window\n *\n * @export\n */\nexport function WindowUnmaximise() {\n    window.WailsInvoke('WU');\n}\n\n/**\n * Returns the state of the window, i.e. whether the window is maximised or not.\n *\n * @export\n * @return {Promise<boolean>} The state of the window\n */\nexport function WindowIsMaximised() {\n    return Call(\":wails:WindowIsMaximised\");\n}\n\n/**\n * Minimise the Window\n *\n * @export\n */\nexport function WindowMinimise() {\n    window.WailsInvoke('Wm');\n}\n\n/**\n * Unminimise the Window\n *\n * @export\n */\nexport function WindowUnminimise() {\n    window.WailsInvoke('Wu');\n}\n\n/**\n * Returns the state of the window, i.e. whether the window is minimised or not.\n *\n * @export\n * @return {Promise<boolean>} The state of the window\n */\nexport function WindowIsMinimised() {\n    return Call(\":wails:WindowIsMinimised\");\n}\n\n/**\n * Returns the state of the window, i.e. whether the window is normal or not.\n *\n * @export\n * @return {Promise<boolean>} The state of the window\n */\nexport function WindowIsNormal() {\n    return Call(\":wails:WindowIsNormal\");\n}\n\n/**\n * Sets the background colour of the window\n *\n * @export\n * @param {number} R Red\n * @param {number} G Green\n * @param {number} B Blue\n * @param {number} A Alpha\n */\nexport function WindowSetBackgroundColour(R, G, B, A) {\n    let rgba = JSON.stringify({r: R || 0, g: G || 0, b: B || 0, a: A || 255});\n    window.WailsInvoke('Wr:' + rgba);\n}\n\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\n\nimport {Call} from \"./calls\";\n\n\n/**\n * Gets the all screens. Call this anew each time you want to refresh data from the underlying windowing system.\n * @export\n * @typedef {import('../wrapper/runtime').Screen} Screen\n * @return {Promise<{Screen[]}>} The screens\n */\nexport function ScreenGetAll() {\n    return Call(\":wails:ScreenGetAll\");\n}\n", "/**\n * @description: Use the system default browser to open the url\n * @param {string} url \n * @return {void}\n */\nexport function BrowserOpenURL(url) {\n  window.WailsInvoke('BO:' + url);\n}", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\nimport {Call} from \"./calls\";\n\n/**\n * Set the Size of the window\n *\n * @export\n * @param {string} text\n */\nexport function ClipboardSetText(text) {\n    return Call(\":wails:ClipboardSetText\", [text]);\n}\n\n/**\n * Get the text content of the clipboard\n *\n * @export\n * @return {Promise<{string}>} Text content of the clipboard\n\n */\nexport function ClipboardGetText() {\n    return Call(\":wails:ClipboardGetText\");\n}", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\nimport {EventsOn, EventsOff} from \"./events\";\n\nconst flags = {\n    registered: false,\n    defaultUseDropTarget: true,\n    useDropTarget: true,\n    nextDeactivate: null,\n    nextDeactivateTimeout: null,\n};\n\nconst DROP_TARGET_ACTIVE = \"wails-drop-target-active\";\n\n/**\n * checkStyleDropTarget checks if the style has the drop target attribute\n * \n * @param {CSSStyleDeclaration} style \n * @returns \n */\nfunction checkStyleDropTarget(style) {\n    const cssDropValue = style.getPropertyValue(window.wails.flags.cssDropProperty).trim();\n    if (cssDropValue) {\n        if (cssDropValue === window.wails.flags.cssDropValue) {\n            return true;\n        }\n        // if the element has the drop target attribute, but \n        // the value is not correct, terminate finding process.\n        // This can be useful to block some child elements from being drop targets.\n        return false;\n    }\n    return false;\n}\n\n/**\n * onDragOver is called when the dragover event is emitted.\n * @param {DragEvent} e \n * @returns \n */\nfunction onDragOver(e) {\n    if (!window.wails.flags.enableWailsDragAndDrop) {\n        return;\n    }\n    e.preventDefault();\n\n    if (!flags.useDropTarget) {\n        return;\n    }\n\n    const element = e.target;\n\n    // Trigger debounce function to deactivate drop targets\n    if(flags.nextDeactivate) flags.nextDeactivate();\n\n    // if the element is null or element is not child of drop target element\n    if (!element || !checkStyleDropTarget(getComputedStyle(element))) {\n        return;\n    }\n\n    let currentElement = element;\n    while (currentElement) {\n        // check if currentElement is drop target element\n        if (checkStyleDropTarget(currentElement.style)) {\n            currentElement.classList.add(DROP_TARGET_ACTIVE);\n        }\n        currentElement = currentElement.parentElement;\n    }\n}\n\n/**\n * onDragLeave is called when the dragleave event is emitted.\n * @param {DragEvent} e \n * @returns \n */\nfunction onDragLeave(e) {\n    if (!window.wails.flags.enableWailsDragAndDrop) {\n        return;\n    }\n    e.preventDefault();\n\n    if (!flags.useDropTarget) {\n        return;\n    }\n\n    // Find the close drop target element\n    if (!e.target || !checkStyleDropTarget(getComputedStyle(e.target))) {\n        return null;\n    }\n\n    // Trigger debounce function to deactivate drop targets\n    if(flags.nextDeactivate) flags.nextDeactivate();\n    \n    // Use debounce technique to tacle dragleave events on overlapping elements and drop target elements\n    flags.nextDeactivate = () => {\n        // Deactivate all drop targets, new drop target will be activated on next dragover event\n        Array.from(document.getElementsByClassName(DROP_TARGET_ACTIVE)).forEach(el => el.classList.remove(DROP_TARGET_ACTIVE));\n        // Reset nextDeactivate\n        flags.nextDeactivate = null;\n        // Clear timeout\n        if (flags.nextDeactivateTimeout) {\n            clearTimeout(flags.nextDeactivateTimeout);\n            flags.nextDeactivateTimeout = null;\n        }\n    }\n\n    // Set timeout to deactivate drop targets if not triggered by next drag event\n    flags.nextDeactivateTimeout = setTimeout(() => {\n        if(flags.nextDeactivate) flags.nextDeactivate();\n    }, 50);\n}\n\n/**\n * onDrop is called when the drop event is emitted.\n * @param {DragEvent} e \n * @returns \n */\nfunction onDrop(e) {\n    if (!window.wails.flags.enableWailsDragAndDrop) {\n        return;\n    }\n    e.preventDefault();\n\n    if (!flags.useDropTarget) {\n        return;\n    }\n\n    // Trigger debounce function to deactivate drop targets\n    if(flags.nextDeactivate) flags.nextDeactivate();\n\n    // Deactivate all drop targets\n    Array.from(document.getElementsByClassName(DROP_TARGET_ACTIVE)).forEach(el => el.classList.remove(DROP_TARGET_ACTIVE));\n\n    if (CanResolveFilePaths()) {\n        // process files\n        let files = [];\n        if (e.dataTransfer.items) {\n            files = [...e.dataTransfer.items].map((item, i) => {\n                if (item.kind === 'file') {\n                    return item.getAsFile();\n                }\n            });\n        } else {\n            files = [...e.dataTransfer.files];\n        }\n        window.runtime.ResolveFilePaths(e.x, e.y, files);\n    }\n}\n\n/**\n * postMessageWithAdditionalObjects checks the browser's capability of sending postMessageWithAdditionalObjects\n *\n * @returns {boolean}\n * @constructor\n */\nexport function CanResolveFilePaths() {\n    return window.chrome?.webview?.postMessageWithAdditionalObjects != null;\n}\n\n/**\n * ResolveFilePaths sends drop events to the GO side to resolve file paths on windows.\n *\n * @param {number} x\n * @param {number} y\n * @param {any[]} files\n * @constructor\n */\nexport function ResolveFilePaths(x, y, files) {\n    // Only for windows webview2 >= 1.0.1774.30\n    // https://learn.microsoft.com/en-us/microsoft-edge/webview2/reference/win32/icorewebview2webmessagereceivedeventargs2?view=webview2-1.0.1823.32#applies-to\n    if (window.chrome?.webview?.postMessageWithAdditionalObjects) {\n        chrome.webview.postMessageWithAdditionalObjects(`file:drop:${x}:${y}`, files);\n    }\n}\n\n/**\n * Callback for OnFileDrop returns a slice of file path strings when a drop is finished.\n *\n * @export\n * @callback OnFileDropCallback\n * @param {number} x - x coordinate of the drop\n * @param {number} y - y coordinate of the drop\n * @param {string[]} paths - A list of file paths.\n */\n\n/**\n * OnFileDrop listens to drag and drop events and calls the callback with the coordinates of the drop and an array of path strings.\n *\n * @export\n * @param {OnFileDropCallback} callback - Callback for OnFileDrop returns a slice of file path strings when a drop is finished.\n * @param {boolean} [useDropTarget=true] - Only call the callback when the drop finished on an element that has the drop target style. (--wails-drop-target)\n */\nexport function OnFileDrop(callback, useDropTarget) {\n    if (typeof callback !== \"function\") {\n        console.error(\"DragAndDropCallback is not a function\");\n        return;\n    }\n\n    if (flags.registered) {\n        return;\n    }\n    flags.registered = true;\n\n    const uDTPT = typeof useDropTarget;\n    flags.useDropTarget = uDTPT === \"undefined\" || uDTPT !== \"boolean\" ? flags.defaultUseDropTarget : useDropTarget;\n    window.addEventListener('dragover', onDragOver);\n    window.addEventListener('dragleave', onDragLeave);\n    window.addEventListener('drop', onDrop);\n\n    let cb = callback;\n    if (flags.useDropTarget) {\n        cb = function (x, y, paths) {\n            const element = document.elementFromPoint(x, y)\n            // if the element is null or element is not child of drop target element, return null\n            if (!element || !checkStyleDropTarget(getComputedStyle(element))) {\n                return null;\n            }\n            callback(x, y, paths);\n        }\n    }\n\n    EventsOn(\"wails:file-drop\", cb);\n}\n\n/**\n * OnFileDropOff removes the drag and drop listeners and handlers.\n */\nexport function OnFileDropOff() {\n    window.removeEventListener('dragover', onDragOver);\n    window.removeEventListener('dragleave', onDragLeave);\n    window.removeEventListener('drop', onDrop);\n    EventsOff(\"wails:file-drop\");\n    flags.registered = false;\n}\n", "/*\n--default-contextmenu: auto; (default) will show the default context menu if contentEditable is true OR text has been selected OR element is input or textarea\n--default-contextmenu: show; will always show the default context menu\n--default-contextmenu: hide; will always hide the default context menu\n\nThis rule is inherited like normal CSS rules, so nesting works as expected\n*/\nexport function processDefaultContextMenu(event) {\n    // Process default context menu\n    const element = event.target;\n    const computedStyle = window.getComputedStyle(element);\n    const defaultContextMenuAction = computedStyle.getPropertyValue(\"--default-contextmenu\").trim();\n    switch (defaultContextMenuAction) {\n        case \"show\":\n            return;\n        case \"hide\":\n            event.preventDefault();\n            return;\n        default:\n            // Check if contentEditable is true\n            if (element.isContentEditable) {\n                return;\n            }\n\n            // Check if text has been selected and action is on the selected elements\n            const selection = window.getSelection();\n            const hasSelection = (selection.toString().length > 0)\n            if (hasSelection) {\n                for (let i = 0; i < selection.rangeCount; i++) {\n                    const range = selection.getRangeAt(i);\n                    const rects = range.getClientRects();\n                    for (let j = 0; j < rects.length; j++) {\n                        const rect = rects[j];\n                        if (document.elementFromPoint(rect.left, rect.top) === element) {\n                            return;\n                        }\n                    }\n                }\n            }\n            // Check if tagname is input or textarea\n            if (element.tagName === \"INPUT\" || element.tagName === \"TEXTAREA\") {\n                if (hasSelection || (!element.readOnly && !element.disabled)) {\n                    return;\n                }\n            }\n\n            // hide default context menu\n            event.preventDefault();\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n/* jshint esversion: 9 */\nimport * as Log from './log';\nimport {eventListeners, EventsEmit, EventsNotify, EventsOff, EventsOn, EventsOnce, EventsOnMultiple} from './events';\nimport {Call, Callback, callbacks} from './calls';\nimport {SetBindings} from \"./bindings\";\nimport * as Window from \"./window\";\nimport * as Screen from \"./screen\";\nimport * as Browser from \"./browser\";\nimport * as Clipboard from \"./clipboard\";\nimport * as DragAndDrop from \"./draganddrop\";\nimport * as ContextMenu from \"./contextmenu\";\n\nexport function Quit() {\n    window.WailsInvoke('Q');\n}\n\nexport function Show() {\n    window.WailsInvoke('S');\n}\n\nexport function Hide() {\n    window.WailsInvoke('H');\n}\n\nexport function Environment() {\n    return Call(\":wails:Environment\");\n}\n\n// The JS runtime\nwindow.runtime = {\n    ...Log,\n    ...Window,\n    ...Browser,\n    ...Screen,\n    ...Clipboard,\n    ...DragAndDrop,\n    EventsOn,\n    EventsOnce,\n    EventsOnMultiple,\n    EventsEmit,\n    EventsOff,\n    Environment,\n    Show,\n    Hide,\n    Quit\n};\n\n// Internal wails endpoints\nwindow.wails = {\n    Callback,\n    EventsNotify,\n    SetBindings,\n    eventListeners,\n    callbacks,\n    flags: {\n        disableScrollbarDrag: false,\n        disableDefaultContextMenu: false,\n        enableResize: false,\n        defaultCursor: null,\n        borderThickness: 6,\n        shouldDrag: false,\n        deferDragToMouseMove: true,\n        cssDragProperty: \"--wails-draggable\",\n        cssDragValue: \"drag\",\n        cssDropProperty: \"--wails-drop-target\",\n        cssDropValue: \"drop\",\n        enableWailsDragAndDrop: false,\n    }\n};\n\n// Set the bindings\nif (window.wailsbindings) {\n    window.wails.SetBindings(window.wailsbindings);\n    delete window.wails.SetBindings;\n}\n\n// (bool) This is evaluated at build time in package.json\nif (!DEBUG) {\n    delete window.wailsbindings;\n}\n\nlet dragTest = function (e) {\n    var val = window.getComputedStyle(e.target).getPropertyValue(window.wails.flags.cssDragProperty);\n    if (val) {\n      val = val.trim();\n    }\n    \n    if (val !== window.wails.flags.cssDragValue) {\n        return false;\n    }\n\n    if (e.buttons !== 1) {\n        // Do not start dragging if not the primary button has been clicked.\n        return false;\n    }\n\n    if (e.detail !== 1) {\n        // Do not start dragging if more than once has been clicked, e.g. when double clicking\n        return false;\n    }\n\n    return true;\n};\n\nwindow.wails.setCSSDragProperties = function (property, value) {\n    window.wails.flags.cssDragProperty = property;\n    window.wails.flags.cssDragValue = value;\n}\n\nwindow.wails.setCSSDropProperties = function (property, value) {\n    window.wails.flags.cssDropProperty = property;\n    window.wails.flags.cssDropValue = value;\n}\n\nwindow.addEventListener('mousedown', (e) => {\n    // Check for resizing\n    if (window.wails.flags.resizeEdge) {\n        window.WailsInvoke(\"resize:\" + window.wails.flags.resizeEdge);\n        e.preventDefault();\n        return;\n    }\n\n    if (dragTest(e)) {\n        if (window.wails.flags.disableScrollbarDrag) {\n            // This checks for clicks on the scroll bar\n            if (e.offsetX > e.target.clientWidth || e.offsetY > e.target.clientHeight) {\n                return;\n            }\n        }\n        if (window.wails.flags.deferDragToMouseMove) {\n            window.wails.flags.shouldDrag = true;\n        } else {\n            e.preventDefault()\n            window.WailsInvoke(\"drag\");\n        }\n        return;\n    } else {\n        window.wails.flags.shouldDrag = false;\n    }\n});\n\nwindow.addEventListener('mouseup', () => {\n    window.wails.flags.shouldDrag = false;\n});\n\nfunction setResize(cursor) {\n    document.documentElement.style.cursor = cursor || window.wails.flags.defaultCursor;\n    window.wails.flags.resizeEdge = cursor;\n}\n\nwindow.addEventListener('mousemove', function (e) {\n    if (window.wails.flags.shouldDrag) {\n        window.wails.flags.shouldDrag = false;\n        let mousePressed = e.buttons !== undefined ? e.buttons : e.which;\n        if (mousePressed > 0) {\n            window.WailsInvoke(\"drag\");\n            return;\n        }\n    }\n    if (!window.wails.flags.enableResize) {\n        return;\n    }\n    if (window.wails.flags.defaultCursor == null) {\n        window.wails.flags.defaultCursor = document.documentElement.style.cursor;\n    }\n    if (window.outerWidth - e.clientX < window.wails.flags.borderThickness && window.outerHeight - e.clientY < window.wails.flags.borderThickness) {\n        document.documentElement.style.cursor = \"se-resize\";\n    }\n    let rightBorder = window.outerWidth - e.clientX < window.wails.flags.borderThickness;\n    let leftBorder = e.clientX < window.wails.flags.borderThickness;\n    let topBorder = e.clientY < window.wails.flags.borderThickness;\n    let bottomBorder = window.outerHeight - e.clientY < window.wails.flags.borderThickness;\n\n    // If we aren't on an edge, but were, reset the cursor to default\n    if (!leftBorder && !rightBorder && !topBorder && !bottomBorder && window.wails.flags.resizeEdge !== undefined) {\n        setResize();\n    } else if (rightBorder && bottomBorder) setResize(\"se-resize\");\n    else if (leftBorder && bottomBorder) setResize(\"sw-resize\");\n    else if (leftBorder && topBorder) setResize(\"nw-resize\");\n    else if (topBorder && rightBorder) setResize(\"ne-resize\");\n    else if (leftBorder) setResize(\"w-resize\");\n    else if (topBorder) setResize(\"n-resize\");\n    else if (bottomBorder) setResize(\"s-resize\");\n    else if (rightBorder) setResize(\"e-resize\");\n\n});\n\n// Setup context menu hook\nwindow.addEventListener('contextmenu', function (e) {\n    // always show the contextmenu in debug & dev\n    if (DEBUG) return;\n\n    if (window.wails.flags.disableDefaultContextMenu) {\n        e.preventDefault();\n    } else {\n        ContextMenu.processDefaultContextMenu(e);\n    }\n});\n\nwindow.WailsInvoke(\"runtime:ready\");"],
  "mappings": "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",
  "names": ["eventName"]
}
 diff --git a/v2/internal/frontend/runtime/runtime_prod_desktop.js b/v2/internal/frontend/runtime/runtime_prod_desktop.js index 9b2f39ff0b0..7be603d4418 100644 --- a/v2/internal/frontend/runtime/runtime_prod_desktop.js +++ b/v2/internal/frontend/runtime/runtime_prod_desktop.js @@ -1 +1 @@ -(()=>{var P=Object.defineProperty;var c=(e,n)=>{for(var o in n)P(e,o,{get:n[o],enumerable:!0})};var x={};c(x,{LogDebug:()=>G,LogError:()=>F,LogFatal:()=>J,LogInfo:()=>H,LogLevel:()=>j,LogPrint:()=>B,LogTrace:()=>A,LogWarning:()=>U,SetLogLevel:()=>N});function f(e,n){window.WailsInvoke("L"+e+n)}function A(e){f("T",e)}function B(e){f("P",e)}function G(e){f("D",e)}function H(e){f("I",e)}function U(e){f("W",e)}function F(e){f("E",e)}function J(e){f("F",e)}function N(e){f("S",e)}var j={TRACE:1,DEBUG:2,INFO:3,WARNING:4,ERROR:5};var v=class{constructor(n,o,t){this.eventName=n,this.maxCallbacks=t||-1,this.Callback=i=>(o.apply(null,i),this.maxCallbacks===-1?!1:(this.maxCallbacks-=1,this.maxCallbacks===0))}},a={};function p(e,n,o){a[e]=a[e]||[];let t=new v(e,n,o);return a[e].push(t),()=>V(t)}function y(e,n){return p(e,n,-1)}function C(e,n){return p(e,n,1)}function D(e){let n=e.name;if(a[n]){let o=a[n].slice();for(let t=a[n].length-1;t>=0;t-=1){let i=a[n][t],r=e.data;i.Callback(r)&&o.splice(t,1)}o.length===0?g(n):a[n]=o}}function T(e){let n;try{n=JSON.parse(e)}catch{let t="Invalid JSON passed to Notify: "+e;throw new Error(t)}D(n)}function O(e){let n={name:e,data:[].slice.apply(arguments).slice(1)};D(n),window.WailsInvoke("EE"+JSON.stringify(n))}function g(e){delete a[e],window.WailsInvoke("EX"+e)}function L(e,...n){g(e),n.length>0&&n.forEach(o=>{g(o)})}function V(e){let n=e.eventName;a[n]=a[n].filter(o=>o!==e),a[n].length===0&&g(n)}var u={};function X(){var e=new Uint32Array(1);return window.crypto.getRandomValues(e)[0]}function Y(){return Math.random()*9007199254740991}var W;window.crypto?W=X:W=Y;function s(e,n,o){return o==null&&(o=0),new Promise(function(t,i){var r;do r=e+"-"+W();while(u[r]);var l;o>0&&(l=setTimeout(function(){i(Error("Call to "+e+" timed out. Request ID: "+r))},o)),u[r]={timeoutHandle:l,reject:i,resolve:t};try{let d={name:e,args:n,callbackID:r};window.WailsInvoke("C"+JSON.stringify(d))}catch(d){console.error(d)}})}window.ObfuscatedCall=(e,n,o)=>(o==null&&(o=0),new Promise(function(t,i){var r;do r=e+"-"+W();while(u[r]);var l;o>0&&(l=setTimeout(function(){i(Error("Call to method "+e+" timed out. Request ID: "+r))},o)),u[r]={timeoutHandle:l,reject:i,resolve:t};try{let d={id:e,args:n,callbackID:r};window.WailsInvoke("c"+JSON.stringify(d))}catch(d){console.error(d)}}));function z(e){let n;try{n=JSON.parse(e)}catch(i){let r=`Invalid JSON passed to callback: ${i.message}. Message: ${e}`;throw runtime.LogDebug(r),new Error(r)}let o=n.callbackid,t=u[o];if(!t){let i=`Callback '${o}' not registered!!!`;throw console.error(i),new Error(i)}clearTimeout(t.timeoutHandle),delete u[o],n.error?t.reject(n.error):t.resolve(n.result)}window.go={};function M(e){try{e=JSON.parse(e)}catch(n){console.error(n)}window.go=window.go||{},Object.keys(e).forEach(n=>{window.go[n]=window.go[n]||{},Object.keys(e[n]).forEach(o=>{window.go[n][o]=window.go[n][o]||{},Object.keys(e[n][o]).forEach(t=>{window.go[n][o][t]=function(){let i=0;function r(){let l=[].slice.call(arguments);return s([n,o,t].join("."),l,i)}return r.setTimeout=function(l){i=l},r.getTimeout=function(){return i},r}()})})})}var h={};c(h,{WindowCenter:()=>_,WindowFullscreen:()=>ne,WindowGetPosition:()=>de,WindowGetSize:()=>re,WindowHide:()=>fe,WindowIsFullscreen:()=>te,WindowIsMaximised:()=>We,WindowIsMinimised:()=>ve,WindowIsNormal:()=>he,WindowMaximise:()=>ce,WindowMinimise:()=>me,WindowReload:()=>$,WindowReloadApp:()=>q,WindowSetAlwaysOnTop:()=>ae,WindowSetBackgroundColour:()=>ke,WindowSetDarkTheme:()=>K,WindowSetLightTheme:()=>Z,WindowSetMaxSize:()=>se,WindowSetMinSize:()=>le,WindowSetPosition:()=>we,WindowSetSize:()=>ie,WindowSetSystemDefaultTheme:()=>Q,WindowSetTitle:()=>ee,WindowShow:()=>ue,WindowToggleMaximise:()=>ge,WindowUnfullscreen:()=>oe,WindowUnmaximise:()=>pe,WindowUnminimise:()=>xe});function $(){window.location.reload()}function q(){window.WailsInvoke("WR")}function Q(){window.WailsInvoke("WASDT")}function Z(){window.WailsInvoke("WALT")}function K(){window.WailsInvoke("WADT")}function _(){window.WailsInvoke("Wc")}function ee(e){window.WailsInvoke("WT"+e)}function ne(){window.WailsInvoke("WF")}function oe(){window.WailsInvoke("Wf")}function te(){return s(":wails:WindowIsFullscreen")}function ie(e,n){window.WailsInvoke("Ws:"+e+":"+n)}function re(){return s(":wails:WindowGetSize")}function se(e,n){window.WailsInvoke("WZ:"+e+":"+n)}function le(e,n){window.WailsInvoke("Wz:"+e+":"+n)}function ae(e){window.WailsInvoke("WATP:"+(e?"1":"0"))}function we(e,n){window.WailsInvoke("Wp:"+e+":"+n)}function de(){return s(":wails:WindowGetPos")}function fe(){window.WailsInvoke("WH")}function ue(){window.WailsInvoke("WS")}function ce(){window.WailsInvoke("WM")}function ge(){window.WailsInvoke("Wt")}function pe(){window.WailsInvoke("WU")}function We(){return s(":wails:WindowIsMaximised")}function me(){window.WailsInvoke("Wm")}function xe(){window.WailsInvoke("Wu")}function ve(){return s(":wails:WindowIsMinimised")}function he(){return s(":wails:WindowIsNormal")}function ke(e,n,o,t){let i=JSON.stringify({r:e||0,g:n||0,b:o||0,a:t||255});window.WailsInvoke("Wr:"+i)}var k={};c(k,{ScreenGetAll:()=>Ie});function Ie(){return s(":wails:ScreenGetAll")}var I={};c(I,{BrowserOpenURL:()=>be});function be(e){window.WailsInvoke("BO:"+e)}var b={};c(b,{ClipboardGetText:()=>Ee,ClipboardSetText:()=>Se});function Se(e){return s(":wails:ClipboardSetText",[e])}function Ee(){return s(":wails:ClipboardGetText")}function R(e){let n=e.target;switch(window.getComputedStyle(n).getPropertyValue("--default-contextmenu").trim()){case"show":return;case"hide":e.preventDefault();return;default:if(n.isContentEditable)return;let i=window.getSelection(),r=i.toString().length>0;if(r)for(let l=0;l{if(window.wails.flags.resizeEdge){window.WailsInvoke("resize:"+window.wails.flags.resizeEdge),e.preventDefault();return}if(Le(e)){if(window.wails.flags.disableScrollbarDrag&&(e.offsetX>e.target.clientWidth||e.offsetY>e.target.clientHeight))return;window.wails.flags.deferDragToMouseMove?window.wails.flags.shouldDrag=!0:(e.preventDefault(),window.WailsInvoke("drag"));return}else window.wails.flags.shouldDrag=!1});window.addEventListener("mouseup",()=>{window.wails.flags.shouldDrag=!1});function w(e){document.documentElement.style.cursor=e||window.wails.flags.defaultCursor,window.wails.flags.resizeEdge=e}window.addEventListener("mousemove",function(e){if(window.wails.flags.shouldDrag&&(window.wails.flags.shouldDrag=!1,(e.buttons!==void 0?e.buttons:e.which)>0)){window.WailsInvoke("drag");return}if(!window.wails.flags.enableResize)return;window.wails.flags.defaultCursor==null&&(window.wails.flags.defaultCursor=document.documentElement.style.cursor),window.outerWidth-e.clientX{var j=Object.defineProperty;var g=(e,t)=>{for(var n in t)j(e,n,{get:t[n],enumerable:!0})};var b={};g(b,{LogDebug:()=>X,LogError:()=>q,LogFatal:()=>Q,LogInfo:()=>$,LogLevel:()=>Z,LogPrint:()=>J,LogTrace:()=>N,LogWarning:()=>Y,SetLogLevel:()=>_});function u(e,t){window.WailsInvoke("L"+e+t)}function N(e){u("T",e)}function J(e){u("P",e)}function X(e){u("D",e)}function $(e){u("I",e)}function Y(e){u("W",e)}function q(e){u("E",e)}function Q(e){u("F",e)}function _(e){u("S",e)}var Z={TRACE:1,DEBUG:2,INFO:3,WARNING:4,ERROR:5};var y=class{constructor(t,n,o){this.eventName=t,this.maxCallbacks=o||-1,this.Callback=i=>(n.apply(null,i),this.maxCallbacks===-1?!1:(this.maxCallbacks-=1,this.maxCallbacks===0))}},w={};function v(e,t,n){w[e]=w[e]||[];let o=new y(e,t,n);return w[e].push(o),()=>K(o)}function W(e,t){return v(e,t,-1)}function A(e,t){return v(e,t,1)}function P(e){let t=e.name;if(w[t]){let n=w[t].slice();for(let o=w[t].length-1;o>=0;o-=1){let i=w[t][o],r=e.data;i.Callback(r)&&n.splice(o,1)}n.length===0?m(t):w[t]=n}}function R(e){let t;try{t=JSON.parse(e)}catch{let o="Invalid JSON passed to Notify: "+e;throw new Error(o)}P(t)}function M(e){let t={name:e,data:[].slice.apply(arguments).slice(1)};P(t),window.WailsInvoke("EE"+JSON.stringify(t))}function m(e){delete w[e],window.WailsInvoke("EX"+e)}function x(e,...t){m(e),t.length>0&&t.forEach(n=>{m(n)})}function K(e){let t=e.eventName;w[t]=w[t].filter(n=>n!==e),w[t].length===0&&m(t)}var c={};function ee(){var e=new Uint32Array(1);return window.crypto.getRandomValues(e)[0]}function te(){return Math.random()*9007199254740991}var D;window.crypto?D=ee:D=te;function a(e,t,n){return n==null&&(n=0),new Promise(function(o,i){var r;do r=e+"-"+D();while(c[r]);var l;n>0&&(l=setTimeout(function(){i(Error("Call to "+e+" timed out. Request ID: "+r))},n)),c[r]={timeoutHandle:l,reject:i,resolve:o};try{let d={name:e,args:t,callbackID:r};window.WailsInvoke("C"+JSON.stringify(d))}catch(d){console.error(d)}})}window.ObfuscatedCall=(e,t,n)=>(n==null&&(n=0),new Promise(function(o,i){var r;do r=e+"-"+D();while(c[r]);var l;n>0&&(l=setTimeout(function(){i(Error("Call to method "+e+" timed out. Request ID: "+r))},n)),c[r]={timeoutHandle:l,reject:i,resolve:o};try{let d={id:e,args:t,callbackID:r};window.WailsInvoke("c"+JSON.stringify(d))}catch(d){console.error(d)}}));function z(e){let t;try{t=JSON.parse(e)}catch(i){let r=`Invalid JSON passed to callback: ${i.message}. Message: ${e}`;throw runtime.LogDebug(r),new Error(r)}let n=t.callbackid,o=c[n];if(!o){let i=`Callback '${n}' not registered!!!`;throw console.error(i),new Error(i)}clearTimeout(o.timeoutHandle),delete c[n],t.error?o.reject(t.error):o.resolve(t.result)}window.go={};function B(e){try{e=JSON.parse(e)}catch(t){console.error(t)}window.go=window.go||{},Object.keys(e).forEach(t=>{window.go[t]=window.go[t]||{},Object.keys(e[t]).forEach(n=>{window.go[t][n]=window.go[t][n]||{},Object.keys(e[t][n]).forEach(o=>{window.go[t][n][o]=function(){let i=0;function r(){let l=[].slice.call(arguments);return a([t,n,o].join("."),l,i)}return r.setTimeout=function(l){i=l},r.getTimeout=function(){return i},r}()})})})}var T={};g(T,{WindowCenter:()=>le,WindowFullscreen:()=>we,WindowGetPosition:()=>We,WindowGetSize:()=>ce,WindowHide:()=>xe,WindowIsFullscreen:()=>fe,WindowIsMaximised:()=>ye,WindowIsMinimised:()=>Se,WindowIsNormal:()=>Ie,WindowMaximise:()=>he,WindowMinimise:()=>Te,WindowReload:()=>ne,WindowReloadApp:()=>oe,WindowSetAlwaysOnTop:()=>me,WindowSetBackgroundColour:()=>Ce,WindowSetDarkTheme:()=>se,WindowSetLightTheme:()=>re,WindowSetMaxSize:()=>ge,WindowSetMinSize:()=>pe,WindowSetPosition:()=>ve,WindowSetSize:()=>ue,WindowSetSystemDefaultTheme:()=>ie,WindowSetTitle:()=>ae,WindowShow:()=>De,WindowToggleMaximise:()=>Ee,WindowUnfullscreen:()=>de,WindowUnmaximise:()=>be,WindowUnminimise:()=>ke});function ne(){window.location.reload()}function oe(){window.WailsInvoke("WR")}function ie(){window.WailsInvoke("WASDT")}function re(){window.WailsInvoke("WALT")}function se(){window.WailsInvoke("WADT")}function le(){window.WailsInvoke("Wc")}function ae(e){window.WailsInvoke("WT"+e)}function we(){window.WailsInvoke("WF")}function de(){window.WailsInvoke("Wf")}function fe(){return a(":wails:WindowIsFullscreen")}function ue(e,t){window.WailsInvoke("Ws:"+e+":"+t)}function ce(){return a(":wails:WindowGetSize")}function ge(e,t){window.WailsInvoke("WZ:"+e+":"+t)}function pe(e,t){window.WailsInvoke("Wz:"+e+":"+t)}function me(e){window.WailsInvoke("WATP:"+(e?"1":"0"))}function ve(e,t){window.WailsInvoke("Wp:"+e+":"+t)}function We(){return a(":wails:WindowGetPos")}function xe(){window.WailsInvoke("WH")}function De(){window.WailsInvoke("WS")}function he(){window.WailsInvoke("WM")}function Ee(){window.WailsInvoke("Wt")}function be(){window.WailsInvoke("WU")}function ye(){return a(":wails:WindowIsMaximised")}function Te(){window.WailsInvoke("Wm")}function ke(){window.WailsInvoke("Wu")}function Se(){return a(":wails:WindowIsMinimised")}function Ie(){return a(":wails:WindowIsNormal")}function Ce(e,t,n,o){let i=JSON.stringify({r:e||0,g:t||0,b:n||0,a:o||255});window.WailsInvoke("Wr:"+i)}var k={};g(k,{ScreenGetAll:()=>Oe});function Oe(){return a(":wails:ScreenGetAll")}var S={};g(S,{BrowserOpenURL:()=>Le});function Le(e){window.WailsInvoke("BO:"+e)}var I={};g(I,{ClipboardGetText:()=>Pe,ClipboardSetText:()=>Ae});function Ae(e){return a(":wails:ClipboardSetText",[e])}function Pe(){return a(":wails:ClipboardGetText")}var C={};g(C,{CanResolveFilePaths:()=>U,OnFileDrop:()=>Me,OnFileDropOff:()=>ze,ResolveFilePaths:()=>Re});var s={registered:!1,defaultUseDropTarget:!0,useDropTarget:!0,nextDeactivate:null,nextDeactivateTimeout:null},p="wails-drop-target-active";function h(e){let t=e.getPropertyValue(window.wails.flags.cssDropProperty).trim();return t?t===window.wails.flags.cssDropValue:!1}function F(e){if(!window.wails.flags.enableWailsDragAndDrop||(e.preventDefault(),!s.useDropTarget))return;let t=e.target;if(s.nextDeactivate&&s.nextDeactivate(),!t||!h(getComputedStyle(t)))return;let n=t;for(;n;)h(n.style)&&n.classList.add(p),n=n.parentElement}function G(e){if(!!window.wails.flags.enableWailsDragAndDrop&&(e.preventDefault(),!!s.useDropTarget)){if(!e.target||!h(getComputedStyle(e.target)))return null;s.nextDeactivate&&s.nextDeactivate(),s.nextDeactivate=()=>{Array.from(document.getElementsByClassName(p)).forEach(t=>t.classList.remove(p)),s.nextDeactivate=null,s.nextDeactivateTimeout&&(clearTimeout(s.nextDeactivateTimeout),s.nextDeactivateTimeout=null)},s.nextDeactivateTimeout=setTimeout(()=>{s.nextDeactivate&&s.nextDeactivate()},50)}}function H(e){if(!!window.wails.flags.enableWailsDragAndDrop&&(e.preventDefault(),!!s.useDropTarget&&(s.nextDeactivate&&s.nextDeactivate(),Array.from(document.getElementsByClassName(p)).forEach(t=>t.classList.remove(p)),U()))){let t=[];e.dataTransfer.items?t=[...e.dataTransfer.items].map((n,o)=>{if(n.kind==="file")return n.getAsFile()}):t=[...e.dataTransfer.files],window.runtime.ResolveFilePaths(e.x,e.y,t)}}function U(){return window.chrome?.webview?.postMessageWithAdditionalObjects!=null}function Re(e,t,n){window.chrome?.webview?.postMessageWithAdditionalObjects&&chrome.webview.postMessageWithAdditionalObjects(`file:drop:${e}:${t}`,n)}function Me(e,t){if(typeof e!="function"){console.error("DragAndDropCallback is not a function");return}if(s.registered)return;s.registered=!0;let n=typeof t;s.useDropTarget=n==="undefined"||n!=="boolean"?s.defaultUseDropTarget:t,window.addEventListener("dragover",F),window.addEventListener("dragleave",G),window.addEventListener("drop",H);let o=e;s.useDropTarget&&(o=function(i,r,l){let d=document.elementFromPoint(i,r);if(!d||!h(getComputedStyle(d)))return null;e(i,r,l)}),W("wails:file-drop",o)}function ze(){window.removeEventListener("dragover",F),window.removeEventListener("dragleave",G),window.removeEventListener("drop",H),x("wails:file-drop"),s.registered=!1}function V(e){let t=e.target;switch(window.getComputedStyle(t).getPropertyValue("--default-contextmenu").trim()){case"show":return;case"hide":e.preventDefault();return;default:if(t.isContentEditable)return;let i=window.getSelection(),r=i.toString().length>0;if(r)for(let l=0;l{if(window.wails.flags.resizeEdge){window.WailsInvoke("resize:"+window.wails.flags.resizeEdge),e.preventDefault();return}if(Ve(e)){if(window.wails.flags.disableScrollbarDrag&&(e.offsetX>e.target.clientWidth||e.offsetY>e.target.clientHeight))return;window.wails.flags.deferDragToMouseMove?window.wails.flags.shouldDrag=!0:(e.preventDefault(),window.WailsInvoke("drag"));return}else window.wails.flags.shouldDrag=!1});window.addEventListener("mouseup",()=>{window.wails.flags.shouldDrag=!1});function f(e){document.documentElement.style.cursor=e||window.wails.flags.defaultCursor,window.wails.flags.resizeEdge=e}window.addEventListener("mousemove",function(e){if(window.wails.flags.shouldDrag&&(window.wails.flags.shouldDrag=!1,(e.buttons!==void 0?e.buttons:e.which)>0)){window.WailsInvoke("drag");return}if(!window.wails.flags.enableResize)return;window.wails.flags.defaultCursor==null&&(window.wails.flags.defaultCursor=document.documentElement.style.cursor),window.outerWidth-e.clientX; // [ClipboardSetText](https://wails.io/docs/reference/runtime/clipboard#clipboardsettext) // Sets a text on the clipboard export function ClipboardSetText(text: string): Promise; + +// [OnFileDrop](https://wails.io/docs/reference/runtime/draganddrop#onfiledrop) +// OnFileDrop listens to drag and drop events and calls the callback with the coordinates of the drop and an array of path strings. +export function OnFileDrop(callback: (x: number, y: number ,paths: string[]) => void, useDropTarget: boolean) :void + +// [OnFileDropOff](https://wails.io/docs/reference/runtime/draganddrop#dragandddropoff) +// OnFileDropOff removes the drag and drop listeners and handlers. +export function OnFileDropOff() :void + +// Check if the file path resolver is available +export function CanResolveFilePaths(): boolean; + +// Resolves file paths for an array of files +export function ResolveFilePaths(files: File[]): void \ No newline at end of file diff --git a/v2/internal/frontend/runtime/wrapper/runtime.js b/v2/internal/frontend/runtime/wrapper/runtime.js index bd4f371ae1d..623397b0ba0 100644 --- a/v2/internal/frontend/runtime/wrapper/runtime.js +++ b/v2/internal/frontend/runtime/wrapper/runtime.js @@ -199,4 +199,40 @@ export function ClipboardGetText() { export function ClipboardSetText(text) { return window.runtime.ClipboardSetText(text); +} + +/** + * Callback for OnFileDrop returns a slice of file path strings when a drop is finished. + * + * @export + * @callback OnFileDropCallback + * @param {number} x - x coordinate of the drop + * @param {number} y - y coordinate of the drop + * @param {string[]} paths - A list of file paths. + */ + +/** + * OnFileDrop listens to drag and drop events and calls the callback with the coordinates of the drop and an array of path strings. + * + * @export + * @param {OnFileDropCallback} callback - Callback for OnFileDrop returns a slice of file path strings when a drop is finished. + * @param {boolean} [useDropTarget=true] - Only call the callback when the drop finished on an element that has the drop target style. (--wails-drop-target) + */ +export function OnFileDrop(callback, useDropTarget) { + return window.runtime.OnFileDrop(callback, useDropTarget); +} + +/** + * OnFileDropOff removes the drag and drop listeners and handlers. + */ +export function OnFileDropOff() { + return window.runtime.OnFileDropOff(); +} + +export function CanResolveFilePaths() { + return window.runtime.CanResolveFilePaths(); +} + +export function ResolveFilePaths(files) { + return window.runtime.ResolveFilePaths(files); } \ No newline at end of file diff --git a/v2/pkg/options/options.go b/v2/pkg/options/options.go index 66d56ceaa5e..282a25691ac 100644 --- a/v2/pkg/options/options.go +++ b/v2/pkg/options/options.go @@ -95,6 +95,9 @@ type App struct { // Debug options for debug builds. These options will be ignored in a production build. Debug Debug + + // DragAndDrop options for drag and drop behavior + DragAndDrop *DragAndDrop } type ErrorFormatter func(error) any @@ -150,6 +153,15 @@ func MergeDefaults(appoptions *App) { if appoptions.CSSDragValue == "" { appoptions.CSSDragValue = "drag" } + if appoptions.DragAndDrop == nil { + appoptions.DragAndDrop = &DragAndDrop{} + } + if appoptions.DragAndDrop.CSSDropProperty == "" { + appoptions.DragAndDrop.CSSDropProperty = "--wails-drop-target" + } + if appoptions.DragAndDrop.CSSDropValue == "" { + appoptions.DragAndDrop.CSSDropValue = "drop" + } if appoptions.BackgroundColour == nil { appoptions.BackgroundColour = &RGBA{ R: 255, @@ -180,6 +192,23 @@ type SecondInstanceData struct { WorkingDirectory string } +type DragAndDrop struct { + + // EnableFileDrop enables wails' drag and drop functionality that returns the dropped in files' absolute paths. + EnableFileDrop bool + + // Disable webview's drag and drop functionality. + // + // It can be used to prevent accidental file opening of dragged in files in the webview, when there is no need for drag and drop. + DisableWebViewDrop bool + + // CSS property to test for drag and drop target elements. Default "--wails-drop-target" + CSSDropProperty string + + // The CSS Value that the CSSDropProperty must have to be a valid drop target. Default "drop" + CSSDropValue string +} + func NewSecondInstanceData() (*SecondInstanceData, error) { ex, err := os.Executable() if err != nil { diff --git a/v2/pkg/runtime/draganddrop.go b/v2/pkg/runtime/draganddrop.go new file mode 100644 index 00000000000..2db9c773ced --- /dev/null +++ b/v2/pkg/runtime/draganddrop.go @@ -0,0 +1,37 @@ +package runtime + +import ( + "context" + "fmt" +) + +// OnFileDrop returns a slice of file path strings when a drop is finished. +func OnFileDrop(ctx context.Context, callback func(x, y int, paths []string)) { + if callback == nil { + LogError(ctx, "OnFileDrop called with a nil callback") + return + } + EventsOn(ctx, "wails:file-drop", func(optionalData ...interface{}) { + if len(optionalData) != 3 { + callback(0, 0, nil) + } + x, ok := optionalData[0].(int) + if !ok { + LogError(ctx, fmt.Sprintf("invalid x coordinate in drag and drop: %v", optionalData[0])) + } + y, ok := optionalData[1].(int) + if !ok { + LogError(ctx, fmt.Sprintf("invalid y coordinate in drag and drop: %v", optionalData[1])) + } + paths, ok := optionalData[2].([]string) + if !ok { + LogError(ctx, fmt.Sprintf("invalid path data in drag and drop: %v", optionalData[2])) + } + callback(x, y, paths) + }) +} + +// OnFileDropOff removes the drag and drop listeners and handlers. +func OnFileDropOff(ctx context.Context) { + EventsOff(ctx, "wails:file-drop") +} diff --git a/website/docs/reference/options.mdx b/website/docs/reference/options.mdx index 19a599b3644..a6026f12662 100644 --- a/website/docs/reference/options.mdx +++ b/website/docs/reference/options.mdx @@ -64,6 +64,12 @@ func main() { UniqueId: "c9c8fd93-6758-4144-87d1-34bdb0a8bd60", OnSecondInstanceLaunch: app.onSecondInstanceLaunch, }, + DragAndDrop: &options.DragAndDrop{ + EnableFileDrop: false, + DisableWebViewDrop: false, + CSSDropProperty: "--wails-drop-target", + CSSDropValue: "drop", + }, Windows: &windows.Options{ WebviewIsTransparent: false, WindowIsTranslucent: false, @@ -537,6 +543,52 @@ Callback that is called when a second instance of your app is launched. Name: OnSecondInstanceLaunch
Type: `func(secondInstanceData SecondInstanceData)` +### Drag and Drop + +Defines the behavior of drag and drop events on the window. + +Name: DragAndDrop
+Type: `options.DragAndDrop` + +#### EnableFileDrop + +EnableFileDrop enables wails' drag and drop functionality that returns the dropped in files' absolute paths. + +When it is set to `true` the [runtime methods](../reference/runtime/draganddrop.mdx) can be used.
+Or you can listen for the `wails:file-drop` event with [runtime EventsOn method](../reference/runtime/events.mdx#eventson) both on the +Javascript and GO side to implement any functionality you would like. + +The event returns the coordinates of the drop and a file path slice. + +Name: EnableFileDrop
+Type: `bool`
+Default: `false` + +#### DisableWebViewDrop + +Disables the webview's drag and drop functionality. + +It can be used to prevent accidental opening of dragged in files in the webview, when there is no need for drag and drop. + +Name: DisableWebViewDrop
+Type: `bool`
+Default: `false` + +#### CSSDropProperty + +CSS property to test for drag and drop target elements. + +Name: CSSDropProperty
+Type: `string`
+Default: `--wails-drop-target` + +#### CSSDropValue + +The CSS Value that the CSSDropProperty must have to be a valid drop target. Default "drop" + +Name: CSSDropValue
+Type: `string`
+Default: `drop` ### Windows diff --git a/website/docs/reference/runtime/draganddrop.mdx b/website/docs/reference/runtime/draganddrop.mdx new file mode 100644 index 00000000000..ca24e968bc0 --- /dev/null +++ b/website/docs/reference/runtime/draganddrop.mdx @@ -0,0 +1,38 @@ +--- +sidebar_position: 10 +--- + +# Drag And Drop + +::: + +This part of the runtime handles dragging and dropping files and or folders in to the window.
+ +To enable this functionality you have to set [EnableFileDrop](../../reference/options.mdx#enablefiledrop) to `true` +in [Application Options](../../reference/options.mdx#drag-and-drop). + +### OnFileDrop + +This method handles the drop event on the window. + +Go: `OnFileDrop(ctx context.Context, callback func(x, y int, paths []string))`
+Calls the callback function with the coordinates inside the window where the drag was released and a slice of absolute file paths. + +JS: `OnFileDrop(callback: (x: number, y: number, paths: string[]) => void, useDropTarget: boolean) :void`
+Calls the callback function with the coordinates inside the window where the drag was released and a slice of absolute file paths. + +When the `useDropTarget` is `true` in addition to calling the callback when the drop happens, it registers event listeners on +the window that are listening for the drag coordinates and checks if the mouse is over an element that has the +[CSSDropProperty](../../reference/options.mdx#cssdropproperty) style. If the element has the required property +it adds the `wails-drop-target-active` class to the element's class list and removes it when the mouse moves off of it. + + +### OnFileDropOff + +This method removes all registered listeners and handlers for drag and drop events. + +Go: `OnFileDropOff(ctx context.Context)`
+Returns: has no return value. + +JS: `OnFileDropOff(): void`
+Returns: has no return value. diff --git a/website/src/pages/changelog.mdx b/website/src/pages/changelog.mdx index b9bcb4d2959..4a47e2b1674 100644 --- a/website/src/pages/changelog.mdx +++ b/website/src/pages/changelog.mdx @@ -72,7 +72,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Remove quarantine attribute on macOS binaries. Changed by @leaanthony in [PR](https://github.com/wailsapp/wails/pull/3118) - Added documentation for a common GStreamer error on Linux systems. Changed by [@mkwsnyder](https://github.com/mkwsnyder) in [PR](https://github.com/wailsapp/wails/pull/3134) - Added documentation on explicity example of importing JS runtime. Changed by [@danawoodman](https://github.com/danawoodman) in [PR](https://github.com/wailsapp/wails/pull/3178) -- Add dock icon right-click exit handling by @almas1992 in [PR](https://github.com/wailsapp/wails/pull/3157) +- Add dock icon right-click exit handling by @almas1992 in [PR](https://github.com/wailsapp/wails/pull/3157) +- Added Drag & Drop (files or folders) support for Windows and Linux. Added by [@lyimmi](https://github.com/lyimmi) in [PR](https://github.com/wailsapp/wails/pull/3203). Based on the work of [@ayatkyo](https://github.com/ayatkyo) for Windows in [PR](https://github.com/wailsapp/wails/pull/2774). +- Added Drag & Drop (files or folders) support for macOS. Added by [@APshenkin](https://github.com/APshenkin) in [PR](https://github.com/wailsapp/wails/pull/3250). +- Fix Drag & Drop JS runtime. Added by [@jakubpeleska](https://github.com/jakubpeleska), provided by [Beam Transfer](https://beamtransfer.io) in [PR](https://github.com/wailsapp/wails/pull/3516). ### Fixed - Fixed vue-ts template build error. Fixed by @atterpac in