diff --git a/microscript/ILibDuktape_Polyfills.c b/microscript/ILibDuktape_Polyfills.c index e48b6e8..ba04a6e 100644 --- a/microscript/ILibDuktape_Polyfills.c +++ b/microscript/ILibDuktape_Polyfills.c @@ -2456,7 +2456,7 @@ void ILibDuktape_Polyfills_JS_Init(duk_context *ctx) duk_peval_string_noresult(ctx, "addCompressedModule('toaster', Buffer.from('eJztW+tz2zYS/xzP+H9ANJmSavWwk+ncjV2348ROq0liZyy5aRtlXIiEJMQUwQNBS2ri//12QVIiKb5kO9feTPDBFvFYLBaL3d/i0f12d+eF8JaST6aKPN3b/zfpuYo55IWQnpBUceHu7uzuvOYWc31mk8C1mSRqysixRy34F5W0yK9M+lCbPO3sERMrNKKiRvNwd2cpAjKjS+IKRQKfAQXukzF3GGELi3mKcJdYYuY5nLoWI3OuprqXiEZnd+f3iIIYKQqVKVT34GucrEaoQm4JpKlS3kG3O5/PO1Rz2hFy0nXCen73de/F6Vn/tA3cYotL12G+TyT7T8AlDHO0JNQDZiw6AhYdOidCEjqRDMqUQGbnkivuTlrEF2M1p5Lt7tjcV5KPApWSU8wajDdZASRFXdI47pNev0GeH/d7/dbuzrve4JfzywF5d3xxcXw26J32yfkFeXF+dtIb9M7P4OslOT77nbzqnZ20CAMpQS9s4UnkHljkKEFmg7j6jKW6H4uQHd9jFh9zCwblTgI6YWQibph0YSzEY3LGfZxFH5izd3ccPuNKK4G/OSLo5NsuCu+GSuJJAU0ZOYplaBpRloHTv7vDx8SEHAsY7XgOVcDPjBwdEcPhbrAwyOfPJLfYpnLO3eLyMczJyLeN5u7Op3Dmx4FrIcugXq79lqqpCVPZDMuiKpiQa2vKHTvJs864ijoymh22YNZL0FLT6I642/WnRou8N+DfBxxVTEq36vjKFoGCfxIoGkZRuXBNGJSiQGnFqWlNA/e6ST7pdaFJfHdEdGZHiT4ojTsxm4fkNtnrXSWakFhMKiGWFL/c7aCeM7MxB0VjoMIN8h2uDPjbIJ8JnV8T4xN0w11Fnjwlt8bQZQuuhm4jyent+idzfHbPfqu6CKnMKVenUM+smKhsVgeEPTNryTkWJPnmmxzKqANYstKtcahQYAP8/tK1QKUCX3YdYVFHK5cRDrGJaiCZCiToRVGdw+SA48oFPPxE3MBxyMEGj/EggdQtLtGVOg4E9RWT5npNabW8Oh99ZJbqnaB+q7BOrOa6gm4HhWlCpuLKAQdhUQ8zW0T53M5fjzCSX6kDFFw2j02KuV4lYOVaUOfjaqFcQY5evv7hKuOjzviYs1g0H1oob5g/fcFcJaljaGJyiX/D8vWMYbXjCdSDiQPbDZO/PKMzBqRhMMqaEnOBrW/Jbex1oumAQXRiavr/4UZxJA3UwPDXYZKGDw4Q6Wf1rmTNUrC+BpjKZ0+Ng3RRTu2k0C1uH+aXRqwKL/QARzBW5t4cwL8rPaoDEk3tVTSGg3gwKJMCouiITN3vPkNHGg8RKDfzWxTwvskh0ngPZD8AqwmyOquAm9v8bFCI+/IScPQsqOuocnoJ/rRWLcBAsg1ARDtbUC8L/gmHXXLbbMJSxWYFHGNCbc7r7giMAE85tGw/E6behpI5n7tMojqvlQyWZUcvzoKJqBAAJps5TLEcWZSMpmAOMKXdxZa88LGpxf84Ej+a6fBzr2SANQhjikaIBsc0eq4fjAFUcbAVCRSFUDGyG0TbS0IBR3H7gKAd15IuEUuiJ23ewx6rWpQIM8F2PDFq6bEy/NP36NwdQCW/c9k/vdh+EguyI/PJ2J2XfCj4F9TFiCIWMmo7hhgIcDVsJYAfMFbQBQAjsLIjJhMA4AAqy2RZT+opw5/DZX2AmbRXaMZtLo0PoCXGcNhfgqedPXs6HL6DfDH334o5k/0pc5zh8Ga/szccepjjYw5S1CB1nQWfRtsV0AMGXNEXSEHonxB1zQDs69/Gh1ZGQ4oGnhxfx2a+JbmnhHzDFEVwm4MQSimoCDmEmXVarGAMgMVVw04CQdYkwqS8P5FiXI/4AK21lcDxHe5aTgBCM40fTnr9N71+//TkR6OZwP9rBGyEYNdAyJeGNFWjEhBIF7G02c0TMfr4nDqOEK7GOgKQV/Mw0Xndrtck34eK27lgY4fp3jvHvs9mI2f54eDgtaD2Owhg31KpOHW0J2pELSI977wEyOM3mkM5LF6sxf0nhgSTe8bm7RDAkrxeOmdoNpY9cMT3766DZKDPWAInksKSnnTCTyz0QQI9FyGdtlMP0OWv3OcjjTifDGTA7kjxgk04rtpIVKc36NHaPdcLVCS8pFTbuhynjkRZA+69cATuFLWPQ4X7RPJV6x122P5FwLpv/PDnah38+WMDwsgCt1BPEv2pmK/ZMff3ILXIE4SuVxFgDT9WEcneFiqm+IzBegc5+0wNwg8zuby29mhWgiYClRKvZG21aAt8VotEIkmOq9bY0cYh9ZRB2X7AOhhDCxSPO0JoaJksh1EZizVZKR3zZlNYE72IDgpNY6VQxXIoKigURAUgyGFvJBm9hqqP4owwTIt3DjKBWlgYbt/Uj+HuEauso46ymCEZm5QjJqS54GDWkuRmwuUADdqYH0Ygv6HlMzd4QOKPHj3KoYkcuWhlyiOby6haPuk8nsvh6WJxT3yKBL4cxgyjwFjKIAk6Ye2RWIAw/mIg8+XdVmbZniKEUI9XXeq8tj0KUPxT6veZvOGIOYScdFDFAeJcK+GFrjVC5FD37tFlt0vOBDlpPw98sL66N4yxpoBfwfMlgb+PG/NkzsgsAAczptcMooB0ZIBHDH+cnvUGv5O2Vs6qaLJC2itDde/YEoYZWUDSDzxPSMXs2hFp/ZCjfDQeVVOMI8JPHR6ES1j/0n70CMPY5HZXWMQWKlmy8rK6mR7W0fcYaXwKY+GNxdqKd5l+O74c/HJ+ATN0kLIunQUN1FSAD1y2CBj6t6+PszXiiLAEM8epImIu34LAVG9GQXEzk7qpolz930/zP2des8KqRm4IP7JYDHKuuePo05cW+b42bopTvf2YGnE0McMp6kbTCLPYNEr2Y4oKyjfbapi5kRTXzMXjpfJ6N+GB8Pu9D+QH8gzrVxBONACX8yx1eFLaYB972N+rcCyVriVyBklvhXtG4Xjv7By001n6zLUfxDFc+nhSGxJtI9XqVinmsrBpPhV0xs2m9vJSCFUUe23JasTuO2ZIRpBuytrJwA1P/KXEmBJsBJqTelTx7GBhT8qwIJ78nro3mzgQLNdvJz9fXVyeDXpvTq9Oehe4t4EC0hTXYUjYgWGUBh3JtLVZLj1RrttTOhz0A9ImCZO8gs3fQW7bIg22QL8Tm9ak9U5bV6h/SKLKGXnpRigdXSehh2RoZP2E3r400gXxAZEuWp3llm7FxqnGTFQ7a0zbqi8F5ieBA3qHEo0V2RauoYgbXQmxBaHuEsJQWJ36jgV1vpDiVNqZlU9PzI7RynjwjNd+IPlv484S3JU5sho9PxREe0mvV8b1rmECpocKFWpyHnF/h5ABUxyvzkapoD3FtSUZVauwOleDABu1yP6WNgw6rbf1X9Z+ytwEilvtbhdtBiGMW1dnNepvMagtDuow/Q0W7aHCEExfQ5EtQpGswP6ecATTA9vxrcKSiv6/1FUADZxZHsKvH559IQ1Pepuspueo+N+/m5IjpgePcZNCKY1yq7e4da8elXiQVcPL5J8Pb1zprNPsPjc9y21K/fPnuLf65HLPeCxhF22FY6q8iJM+77nHOQ8mXTuc0dqHPZgKZVDQX7HFKRlvoDheYFzdPTaubQgFxKSUMxQQNmySjROQasOG1+lfnfSOX5//XF73nxU4Y9vHqTOjz5/J41yzs1GwtlgPfpFLYcjskFMphawVlW59PevRo1rm8iqMj2p5HdQd9Cuxrq3dyEbcBwUehfm+YZ7wAs/YxPFGPXdS6ila9bxNRqUOtPbUwFNpEVX5lEgqVbAkQ7S+y8hpfH+bnE+02q1sS7TY3Mc+qtDSlvf15W51ft1qzWX361br163Wr1utZenrVuuDbLWWmeBF9PlwuKzGvmT2gdH3YHvOX9VFb/FGIvzcZhuyxhYkVKncgKys/E+4vpDCyH+EIfqrE42quvGM67v1YxHAArgHy/WfEZTctkvmhXfqolekOZfq4qGtt6FLlnxG0/LGmaJXA0Sm62c06SYXhN0Ub2Kvq32E3ALtyYop+3otJ5yJH3Pxcf71sPDd2eajvvBRHmIOyl0mNx4IZorM9RtBFHTxazcEJlpih5v5o/BC7GH2xH/jnmSO4m9oAQysHWGaXLUere6XhxPYZ2ogqb5Gbn4i/l940/FgbZnCjEHq8VxE4tx1lpAnA1Ywa9E9XwTsWlgn3Md3Rsw2svZk9ZYkfP+6Se82u0aUNTWzNjtHPBnCpUTriDvtgdsrZYAFFy0/FKKiKvAPiCGuYaQeRqWJF2s1x/bAg9P6V7RzP8I5QH8yEzd4H3tzPlrkX3rnPprTnIfM8ZvcmbADh3VCgOhHL2NX73MPq9/V17mxuX7nW1UzuXYTNz4R+f5vXtintmNJje3Wja3W4gf1+c/467zev0sn61gCVJTod97+FMx3F4Xe3u9G91v97red+KrrZzKRzCMNxPhxsBE/w2+/PAL0j4+NTPLk6dFRplJoFsJn+vol0dDIDQhKHs/Lgmfm0Yt5vMRvGEmHcftftCriLg==', 'base64'));"); // notifybar-desktop, refer to modules/notifybar-desktop.js - duk_peval_string_noresult(ctx, "addCompressedModule('notifybar-desktop', Buffer.from('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', 'base64'));"); + duk_peval_string_noresult(ctx, "addCompressedModule('notifybar-desktop', Buffer.from('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', 'base64'), '2022-01-27T16:13:36.000-08:00');"); // proxy-helper, refer to modules/proxy-helper.js duk_peval_string_noresult(ctx, "addCompressedModule('proxy-helper', Buffer.from('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', 'base64'));"); diff --git a/modules/notifybar-desktop.js b/modules/notifybar-desktop.js index e06e0c5..7db0cca 100644 --- a/modules/notifybar-desktop.js +++ b/modules/notifybar-desktop.js @@ -16,7 +16,134 @@ limitations under the License. var ptrsize = require('_GenericMarshal').PointerSize; var ClientMessage = 33; +var GM = require('_GenericMarshal'); +const FW_DONTCARE = 0; +const DEFAULT_CHARSET = 1; +const OUT_DEFAULT_PRECIS = 0; +const CLIP_DEFAULT_PRECIS = 0; +const DEFAULT_QUALITY = 0; +const DEFAULT_PITCH = 0; +const FF_SWISS = (2 << 4); /* Variable stroke width, sans-serifed. */ +const WM_COMMAND = 0x0111; +const WM_MOUSEMOVE = 0x0200; +const WM_SETFONT = 0x0030; + +const WS_CHILD = 0x40000000; +const WS_TABSTOP = 0x00010000; +const WS_VISIBLE = 0x10000000; + +const STM_SETIMAGE = 0x0172; +const STM_GETIMAGE = 0x0173; +const IMAGE_BITMAP = 0; +const SmoothingModeAntiAlias = 5; +const InterpolationModeBicubic = 8; + +const BS_BITMAP = 0x00000080; +const BS_DEFPUSHBUTTON = 0x00000001; +const BM_SETIMAGE = 0x00F7; + +const SS_BITMAP = 0x0000000E; +const SS_REALSIZECONTROL = 0x00000040; +const SS_LEFT = 0x00000000; +const SS_CENTERIMAGE = 0x00000200; + +const MK_LBUTTON = 0x001; +const SWP_NOSIZE = 0x0001; +const SWP_NOZORDER = 0x0004; + +const WS_SIZEBOX = 0x00040000; + +var SHM = GM.CreateNativeProxy('Shlwapi.dll'); +SHM.CreateMethod('SHCreateMemStream'); +var gdip = GM.CreateNativeProxy('Gdiplus.dll'); +gdip.CreateMethod('GdipBitmapSetResolution'); +gdip.CreateMethod('GdipCreateBitmapFromStream'); +gdip.CreateMethod('GdipCreateBitmapFromScan0'); +gdip.CreateMethod('GdipCreateHBITMAPFromBitmap'); +gdip.CreateMethod('GdipDisposeImage'); +gdip.CreateMethod('GdipDrawImageRectI'); +gdip.CreateMethod('GdipFree'); +gdip.CreateMethod('GdipLoadImageFromStream'); +gdip.CreateMethod('GdipGetImageGraphicsContext'); +gdip.CreateMethod('GdipGetImageHorizontalResolution'); +gdip.CreateMethod('GdipGetImagePixelFormat'); +gdip.CreateMethod('GdipGetImageVerticalResolution'); +gdip.CreateMethod('GdipSetInterpolationMode'); +gdip.CreateMethod('GdipSetSmoothingMode'); +gdip.CreateMethod('GdiplusStartup'); +gdip.CreateMethod('GdiplusShutdown'); + +const x_icon = 'iVBORw0KGgoAAAANSUhEUgAAAGQAAABkCAYAAABw4pVUAAAAAXNSR0IArs4c6QAABKlJREFUeF7t3U1S20AQBeAZmaIw5A7ANpfxKmyS4yUbZeXLsMXhDrYpB6SUBBK2kDT66X7zqDRbTNzuT29mNJYU7+yHqgOeqhorxhkI2UFgIAZC1gGyciwhBkLWAbJyLCEGQtYBsnIsIQZC1gGyciwhBkLWAbJyLCEGQtYBsnIsIQZC1gGyciwhBuLc82KxSi4uvvvr6x/+/v7A1JP869fz5z+PP/3T4dfZy2GNrg2ekHyxWOVZlro8P3fL5drf3t6xoBQYLw+b1D/tV875Q56c3aFRoCAnGNWhR4JyjOHzvKwu9wkcBQbSikGC0oZRlYZGgYCUc0Y1THUNypGSUs4Zm8c02W9XVTKaJSJR1EEGYURKyhAMdFJUQUZhgFH6hqmuECOSogbSO2eE1pLKw9cUDFRSVEBmYSgnpcTYbFK/33fOGaHjRTMp4iAFRpZlqS/OM+b+CCdFAkM7KaIgk+aMEJoQypgJPFSSJooYSInxkqXOCSSj2ZGZKK8YmzSZMUyhJnoxkL9XX9Jku/3m3etZrvjPRBTJYarzMy2vfif77Z3EZxYDef3gj6nvOcGaXfBIlDmrqcG1jqwp9O+KgZR7P0QonxGj6KEoyDvKvGVl6CgK7RJjhimdnWpxkNhJqVdTu+1KbT67XK79jc7XBiogFUq5aafZmMb4/ZmTUY0KaiBolOL9qi+XunZtg0Nh6AWKyYCAnKAor74y513xTZ8ahvBqqsteNSH1GS1g9VWc/ah9GBCGyiqr84z26PtqtaM4NORM+T0QAwoCW31NaXrX3wDmjOZbq6W8Lynqqy8JFHAyYJN6W28g5wpzUCJhwIes4x5BtlmmoETEiApCOadExogO8o6ivPc1JCkEGBQgJ0nR3GbpQyHBoAE5OaNHoxBhUIFEQSHDoAM5nlOS3W41ZOif/BpCDF6Qh4fygoTJzR7yhwYS7pLGpTq970qIAt86CW6paG7Tt705GQoFCOSCBFv2hoeoehJ/u40s6rY8SVKiJiR6MprHDAFKNBDIBQnDQnr6qsgoUUDgq6mxMBFR4CC02+4kwxcUhG7OCCUnQlJgILRzBhkKBASRjLy4LovsVoiQddvv1UEgc8Zyuc68d3PuGww2DzR8qYJALmZ4u1SnaCjb/SlB5JYXqIFAktG4bqp+T80vuZSTogKCmDO67hGBpFIRRRwkJkY1AkDSqYQiCsKAcYqifDWLAooYCOQ8Y2QDGGsKTfRiINS3RWtv7zPeFq364IDLy7W/uZn8KEDN1Zf0c0/EElJE8VM8WkNwSSyNoXLViciTgKqBduScERqfJVdfGhgqIOXXshJPBBLGkFx9aWGogVQo9eNgQ4du8/fKdy7NSYomhipIPaeMfUKQUjKa5vWSeLcf/IABbQx1kNEoM1dTY4M4ZpsFgQEBGbz6AiWjLSmhex5RGDCQ4JwSCWPI3hcSAwrSiRIZo2/1hcaAg3xAIcFoS8p/8TD+6oPbf1fRvfwQ3ToZu8qx13/sgIGQHRUGYiBkHSArxxJiIGQdICvHEmIgZB0gK8cSYiBkHSArxxJiIGQdICvHEmIgZB0gK8cSYiBkHSArxxJiIGQdICvnH1Bw7aEQPNppAAAAAElFTkSuQmCC'; + +function RGB(r, g, b) +{ + return (r | (g << 8) | (b << 16)); +} +function gdip_RGB(r, g, b) +{ + if (g != null && b != null) + { + return (b | (g << 8) | (r << 16)); + } + else + { + var _r = (r & 0xFF); + var _g = ((r >> 8) & 0xFF); + var _b = ((r >> 16) & 0xFF); + return (RGB(_b, _g, _r)); + } +} +function getScaledImage(b64, width, height) +{ + + var startupinput = require('_GenericMarshal').CreateVariable(24); + var gdipToken = require('_GenericMarshal').CreatePointer(); + + startupinput.toBuffer().writeUInt32LE(1); + gdip.GdiplusStartup(gdipToken, startupinput, 0); + + var raw = Buffer.from(b64, 'base64'); + var nbuff = require('_GenericMarshal').CreateVariable(raw.length); + raw.copy(nbuff.toBuffer()); + var istream = SHM.SHCreateMemStream(nbuff, raw.length); + + var pimage = require('_GenericMarshal').CreatePointer(); + var hbitmap = require('_GenericMarshal').CreatePointer(); + var status = gdip.GdipCreateBitmapFromStream(istream, pimage); + status = gdip.GdipCreateHBITMAPFromBitmap(pimage.Deref(), hbitmap, RGB(0, 54, 105)); + if (status.Val == 0) + { + var format = GM.CreateVariable(4); + console.info1('PixelFormatStatus: ' + gdip.GdipGetImagePixelFormat(pimage.Deref(), format).Val); + console.info1('PixelFormat: ' + format.toBuffer().readInt32LE()); + var nb = GM.CreatePointer(); + + console.info1('FromScan0: ' + gdip.GdipCreateBitmapFromScan0(width, height, 0, format.toBuffer().readInt32LE(), 0, nb).Val); + + var REAL_h = GM.CreateVariable(4); + var REAL_w = GM.CreateVariable(4); + console.info1('GetRes_W: ' + gdip.GdipGetImageHorizontalResolution(pimage.Deref(), REAL_w).Val); + console.info1('GetRes_H: ' + gdip.GdipGetImageVerticalResolution(pimage.Deref(), REAL_h).Val); + console.info1('Source DPI: ' + REAL_w.toBuffer().readFloatLE() + ' X ' + REAL_h.toBuffer().readFloatLE()); + console.info1('SetRes: ' + gdip.GdipBitmapSetResolution(nb.Deref(), REAL_w.toBuffer().readFloatLE(), REAL_h.toBuffer().readFloatLE()).Val); + + var graphics = GM.CreatePointer(); + console.info1('GdipGetImageGraphicsContext: ' + gdip.GdipGetImageGraphicsContext(nb.Deref(), graphics).Val); + console.info1('GdipSetSmoothingMode: ' + gdip.GdipSetSmoothingMode(graphics.Deref(), SmoothingModeAntiAlias).Val); + console.info1('InterpolationModeBicubic: ' + gdip.GdipSetInterpolationMode(graphics.Deref(), InterpolationModeBicubic).Val); + console.info1('DrawImage: ' + gdip.GdipDrawImageRectI(graphics.Deref(), pimage.Deref(), 0, 0, width, height).Val); + + var scaledhbitmap = GM.CreatePointer(); + //console.info1('GetScaledHBITMAP: ' + gdip.GdipCreateHBITMAPFromBitmap(nb.Deref(), scaledhbitmap, options.background).Val); + console.info1('GetScaledHBITMAP: ' + gdip.GdipCreateHBITMAPFromBitmap(nb.Deref(), scaledhbitmap, gdip_RGB(0, 54, 105)).Val); + console.info1('ImageDispose: ' + gdip.GdipDisposeImage(pimage.Deref()).Val); + scaledhbitmap._token = gdipToken; + return (scaledhbitmap); + } + + return (null); +} function windows_notifybar_check(title, tsid) { @@ -32,7 +159,7 @@ function windows_notifybar_check(title, tsid) function windows_notifybar_system(title, tsid) { var ret = {}; - + var script = Buffer.from("require('notifybar-desktop')('" + title + "').on('close', function(){process._exit();});require('DescriptorEvents').addDescriptor(require('util-descriptors').getProcessHandle(" + process.pid + ")).on('signaled', function(){process._exit();});").toString('base64'); require('events').EventEmitter.call(ret, true) @@ -77,27 +204,64 @@ function windows_notifybar_local(title) for (var i in m) { - //console.log('Monitor: ' + i + ' = Width[' + (m[i].right - m[i].left) + ']'); monWidth = (m[i].right - m[i].left); monHeight = (m[i].bottom - m[i].top); barWidth = Math.floor(monWidth * 0.30); barHeight = Math.floor(monHeight * 0.035); + console.info1('Monitor: ' + i + ' = Width[' + (m[i].right - m[i].left) + '] BarHeight[' + barHeight + '] BarWidth[' + barWidth + ']'); + offset = Math.floor(monWidth * 0.50) - Math.floor(barWidth * 0.50); start = m[i].left + offset; var options = { window: { - winstyles: MessagePump.WindowStyles.WS_VISIBLE | MessagePump.WindowStyles.WS_BORDER | MessagePump.WindowStyles.WS_CAPTION | MessagePump.WindowStyles.WS_SYSMENU, + winstyles: MessagePump.WindowStyles.WS_VISIBLE | MessagePump.WindowStyles.WS_POPUP | MessagePump.WindowStyles.WS_BORDER /*| MessagePump.WindowStyles.WS_CAPTION | MessagePump.WindowStyles.WS_SYSMENU*/, x: start, y: m[i].top, left: m[i].left, right: m[i].right, width: barWidth, height: barHeight, title: this.notifybar.title } }; this.notifybar._pumps.push(new MessagePump(options)); + this.notifybar._pumps.peek()._L = m[i].left; + this.notifybar._pumps.peek()._R = m[i].right; + + this.notifybar._pumps.peek()._X = options.window.x; + this.notifybar._pumps.peek()._Y = options.window.y; + this.notifybar._pumps.peek().i = i; this.notifybar._pumps.peek().notifybar = this.notifybar; + this.notifybar._pumps.peek().width = barWidth; + this.notifybar._pumps.peek().height = barHeight; + this.notifybar._pumps.peek().font = this.notifybar._pumps.peek()._gdi32.CreateFontW(barHeight/2, 0, 0, 0, FW_DONTCARE, 0, 0, 0, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_SWISS, require('_GenericMarshal').CreateVariable('Arial', { wide: true })); + this.notifybar._pumps.peek()._title = this.notifybar.title; this.notifybar._pumps.peek().on('hwnd', function (h) { this._HANDLE = h; + this._icon = getScaledImage(x_icon, this.height * 0.75, this.height * 0.75); + this._addCreateWindowEx(0, GM.CreateVariable('BUTTON', { wide: true }), GM.CreateVariable('X', { wide: true }), WS_TABSTOP | WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON | BS_BITMAP, + this.width - (this.height * 0.75) - (this.height * 0.125), // x position + this.height * 0.125, // y position + this.height * 0.75, // Button width + this.height * 0.75, // Button height + h, // Parent window + 0xFFF0, // Child ID + 0, + 0).then(function (c) + { + this.pump._addAsyncMethodCall(this.pump._user32.SendMessageW.async, [c, BM_SETIMAGE, IMAGE_BITMAP, this.pump._icon.Deref()]); + }).parentPromise.pump = this; + this._addCreateWindowEx(0, GM.CreateVariable('STATIC', { wide: true }), GM.CreateVariable(this._title, { wide: true }), WS_TABSTOP | WS_VISIBLE | WS_CHILD | SS_LEFT | SS_CENTERIMAGE, + this.height * 0.125, // x position + this.height * 0.125, // y position + this.width - (this.height), // Button width + this.height * 0.75, // Button height + h, // Parent window + 0xFFF1, // Child ID + 0, + 0).then(function (h) + { + this.pump._addAsyncMethodCall(this.pump._user32.SendMessageW.async, [h, WM_SETFONT, this.pump.font, 1]); + }).parentPromise.pump = this; + //this._addAsyncMethodCall(this._user32.SendMessageW.async, [h, WM_SETFONT, this.font, 1]).then(function (r) { console.log('FONT: ' + r.Val); }); }); this.notifybar._pumps.peek().on('exit', function (h) { @@ -111,53 +275,49 @@ function windows_notifybar_local(title) }); this.notifybar._pumps.peek().on('message', function onWindowsMessage(msg) { - if (msg.message == 133) + switch (msg.message) { - //console.log("WM_NCPAINT"); - } - if (msg.message == 70) // We are intercepting WM_WINDOWPOSCHANGING to DISABLE moving the window - { - if (this._HANDLE) - { - var flags = 0; - switch (ptrsize) + case WM_COMMAND: + switch (msg.wparam) { - case 4: - flags = msg.lparam_raw.Deref(24, 4).toBuffer().readUInt32LE() | 0x0002; // Set SWP_NOMOVE - - // If the bar is too far left, adjust to left most position - if (msg.lparam_raw.Deref(8, 4).toBuffer().readInt32LE() < this._options.window.left) { - msg.lparam_raw.Deref(8, 4).toBuffer().writeInt32LE(this._options.window.left); - } - - // If the bar is too far right, adjust to right most position - if ((msg.lparam_raw.Deref(8, 4).toBuffer().readInt32LE() + this._options.window.width) >= this._options.window.right) { - msg.lparam_raw.Deref(8, 4).toBuffer().writeInt32LE(this._options.window.right - this._options.window.width); - } - - // Lock the bar to the y axis - msg.lparam_raw.Deref(12, 4).toBuffer().writeInt32LE(this._options.window.y); - - break; - case 8: - flags = msg.lparam_raw.Deref(32, 4).toBuffer().readUInt32LE() | 0x0002 // Set SWP_NOMOVE - - // If the bar is too far left, adjust to left most position - if (msg.lparam_raw.Deref(16, 4).toBuffer().readInt32LE() < this._options.window.left) { - msg.lparam_raw.Deref(16, 4).toBuffer().writeInt32LE(this._options.window.left); - } - - // If the bar is too far right, adjust to right most position - if ((msg.lparam_raw.Deref(32, 4).toBuffer().readInt32LE() + this._options.window.width) >= this._options.window.right) { - msg.lparam_raw.Deref(32, 4).toBuffer().writeInt32LE(this._options.window.right - this._options.window.width); - } - - // Lock the bar to the y axis - msg.lparam_raw.Deref(20, 4).toBuffer().writeInt32LE(this._options.window.y); - + case 0xFFF0: + this.close(); break; } - } + break; + case WM_MOUSEMOVE: + if ((msg.wparam & MK_LBUTTON) == MK_LBUTTON) + { + if (this._swp == null) + { + if (this._TX == null) + { + this._TX = msg.lparam & 0xFFFF; + } + else + { + var v = this.width / 12; + if ((msg.lparam & 0xFFF) < this._TX) + { + // Move Left + this._TX = msg.lparam & 0xFFFF; + v = this._X - v; + if (v < this._L) { v = this._L; } + } + else + { + // Move Right + this._TX = msg.lparam & 0xFFFF; + v = this._X + v; + if ((v + this.width) > this._R) { v = this._R - this.width; } + } + this._X = v; + this._swp = this._addAsyncMethodCall(this._user32.SetWindowPos.async, [this._HANDLE, 0, v, 0, -1, -1, SWP_NOSIZE | SWP_NOZORDER]); + this._swp.then(function () { this.pump._swp = null; this.pump._TX = null; }).parentPromise.pump = this; + } + } + } + break; } }); }