@esslassi/electron-printer 0.0.2 → 0.0.5

package/src/windows_printer.cpp

@@ -0,0 +1,210 @@
+#include "windows_printer.h"
+#include <vector>
+
+std::string WindowsPrinter::GetPrinterStatus(DWORD status)
+{
+    if (status & PRINTER_STATUS_OFFLINE)
+        return "offline";
+    if (status & PRINTER_STATUS_ERROR)
+        return "error";
+    if (status & PRINTER_STATUS_PAPER_JAM)
+        return "paper-jam";
+    if (status & PRINTER_STATUS_PAPER_OUT)
+        return "paper-out";
+    if (status & PRINTER_STATUS_MANUAL_FEED)
+        return "manual-feed";
+    if (status & PRINTER_STATUS_PAPER_PROBLEM)
+        return "paper-problem";
+    if (status & PRINTER_STATUS_BUSY)
+        return "busy";
+    if (status & PRINTER_STATUS_PRINTING)
+        return "printing";
+    if (status & PRINTER_STATUS_OUTPUT_BIN_FULL)
+        return "output-bin-full";
+    if (status & PRINTER_STATUS_NOT_AVAILABLE)
+        return "not-available";
+    if (status & PRINTER_STATUS_WAITING)
+        return "waiting";
+    if (status & PRINTER_STATUS_PROCESSING)
+        return "processing";
+    if (status & PRINTER_STATUS_INITIALIZING)
+        return "initializing";
+    if (status & PRINTER_STATUS_WARMING_UP)
+        return "warming-up";
+    if (status & PRINTER_STATUS_TONER_LOW)
+        return "toner-low";
+    if (status & PRINTER_STATUS_NO_TONER)
+        return "no-toner";
+    if (status & PRINTER_STATUS_PAGE_PUNT)
+        return "page-punt";
+    if (status & PRINTER_STATUS_USER_INTERVENTION)
+        return "user-intervention";
+    if (status & PRINTER_STATUS_OUT_OF_MEMORY)
+        return "out-of-memory";
+    if (status & PRINTER_STATUS_DOOR_OPEN)
+        return "door-open";
+    return "ready";
+}
+
+std::wstring WindowsPrinter::Utf8ToWide(const std::string &str)
+{
+    std::wstring wstr;
+    int len = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, NULL, 0);
+    if (len > 0)
+    {
+        wstr.resize(len - 1);
+        MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, &wstr[0], len);
+    }
+    return wstr;
+}
+
+std::string WindowsPrinter::WideToUtf8(LPWSTR wstr)
+{
+    if (!wstr)
+        return "";
+
+    int len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);
+    if (len <= 0)
+        return "";
+
+    std::vector<char> buffer(len);
+    WideCharToMultiByte(CP_UTF8, 0, wstr, -1, buffer.data(), len, NULL, NULL);
+    return std::string(buffer.data());
+}
+
+PrinterInfo WindowsPrinter::GetPrinterDetails(const std::string &printerName, bool isDefault)
+{
+    PrinterInfo info;
+    info.name = printerName;
+    info.isDefault = isDefault;
+
+    HANDLE hPrinter;
+    std::wstring wPrinterName = Utf8ToWide(printerName);
+
+    if (OpenPrinterW((LPWSTR)wPrinterName.c_str(), &hPrinter, NULL))
+    {
+        DWORD needed;
+        GetPrinterW(hPrinter, 2, NULL, 0, &needed);
+        if (needed > 0)
+        {
+            std::vector<BYTE> buffer(needed);
+            if (GetPrinterW(hPrinter, 2, buffer.data(), needed, &needed))
+            {
+                PRINTER_INFO_2W *pInfo = (PRINTER_INFO_2W *)buffer.data();
+                info.status = GetPrinterStatus(pInfo->Status);
+
+                if (pInfo->pLocation)
+                    info.details["location"] = WideToUtf8(pInfo->pLocation);
+                if (pInfo->pComment)
+                    info.details["comment"] = WideToUtf8(pInfo->pComment);
+                if (pInfo->pDriverName)
+                    info.details["driver"] = WideToUtf8(pInfo->pDriverName);
+                if (pInfo->pPortName)
+                    info.details["port"] = WideToUtf8(pInfo->pPortName);
+            }
+        }
+        ClosePrinter(hPrinter);
+    }
+
+    return info;
+}
+
+std::vector<PrinterInfo> WindowsPrinter::GetPrinters()
+{
+    std::vector<PrinterInfo> printers;
+    DWORD needed = 0, returned = 0;
+
+    EnumPrintersW(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS, NULL, 2, NULL, 0, &needed, &returned);
+    if (needed > 0)
+    {
+        std::vector<BYTE> buffer(needed);
+        if (EnumPrintersW(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS, NULL, 2, buffer.data(), needed, &needed, &returned))
+        {
+            PRINTER_INFO_2W *pInfo = (PRINTER_INFO_2W *)buffer.data();
+            for (DWORD i = 0; i < returned; i++)
+            {
+                std::string name = WideToUtf8(pInfo[i].pPrinterName);
+                bool isDefault = false;
+
+                wchar_t defaultPrinter[256];
+                DWORD size = sizeof(defaultPrinter) / sizeof(defaultPrinter[0]);
+                if (GetDefaultPrinterW(defaultPrinter, &size))
+                {
+                    isDefault = (wcscmp(pInfo[i].pPrinterName, defaultPrinter) == 0);
+                }
+
+                printers.push_back(GetPrinterDetails(name, isDefault));
+            }
+        }
+    }
+
+    return printers;
+}
+
+PrinterInfo WindowsPrinter::GetSystemDefaultPrinter()
+{
+    wchar_t printerName[256];
+    DWORD size = sizeof(printerName) / sizeof(printerName[0]);
+
+    if (GetDefaultPrinterW(printerName, &size))
+    {
+        std::string name = WideToUtf8(printerName);
+        return GetPrinterDetails(name, true);
+    }
+
+    return PrinterInfo();
+}
+
+bool WindowsPrinter::PrintDirect(const std::string &printerName, const std::vector<uint8_t> &data, const std::string &dataType)
+{
+    HANDLE hPrinter;
+    std::wstring wPrinterName = Utf8ToWide(printerName);
+    std::wstring wDataType = Utf8ToWide(dataType);
+
+    if (!OpenPrinterW((LPWSTR)wPrinterName.c_str(), &hPrinter, NULL))
+    {
+        return false;
+    }
+
+    DOC_INFO_1W docInfo;
+    wchar_t docName[] = L"Node.js Print Job";
+    docInfo.pDocName = docName;
+    docInfo.pOutputFile = NULL;
+    docInfo.pDatatype = const_cast<LPWSTR>(wDataType.c_str());
+
+    if (StartDocPrinterW(hPrinter, 1, (LPBYTE)&docInfo))
+    {
+        if (StartPagePrinter(hPrinter))
+        {
+            DWORD bytesWritten;
+            void *buffer = const_cast<void *>(static_cast<const void *>(data.data()));
+            if (WritePrinter(hPrinter, buffer, static_cast<DWORD>(data.size()), &bytesWritten))
+            {
+                EndPagePrinter(hPrinter);
+                EndDocPrinter(hPrinter);
+                ClosePrinter(hPrinter);
+                return true;
+            }
+        }
+        EndDocPrinter(hPrinter);
+    }
+
+    ClosePrinter(hPrinter);
+    return false;
+}
+
+PrinterInfo WindowsPrinter::GetStatusPrinter(const std::string &printerName)
+{
+    wchar_t defaultPrinter[256];
+    DWORD size = sizeof(defaultPrinter) / sizeof(defaultPrinter[0]);
+    bool isDefault = false;
+
+    if (GetDefaultPrinterW(defaultPrinter, &size))
+    {
+        std::string defaultPrinterName = WideToUtf8(defaultPrinter);
+        isDefault = (printerName == defaultPrinterName);
+    }
+
+    PrinterInfo printer = GetPrinterDetails(printerName, isDefault);
+    return printer;
+}

package/src/windows_printer.h

@@ -0,0 +1,35 @@
+#ifndef WINDOWS_PRINTER_H
+#define WINDOWS_PRINTER_H
+
+#define NOMINMAX
+#include <windows.h>
+#include <winspool.h>
+#include <cstdint>
+#include "printer_interface.h"
+#include <vector>
+
+// Desabilita todas as macros do Windows que podem interferir
+#ifdef GetDefaultPrinter
+#undef GetDefaultPrinter
+#endif
+
+#ifdef GetPrinter
+#undef GetPrinter
+#endif
+
+class WindowsPrinter : public PrinterInterface
+{
+private:
+    std::string GetPrinterStatus(DWORD status);
+    std::wstring Utf8ToWide(const std::string &str);
+    std::string WideToUtf8(LPWSTR wstr);
+
+public:
+    virtual PrinterInfo GetPrinterDetails(const std::string &printerName, bool isDefault = false) override;
+    virtual std::vector<PrinterInfo> GetPrinters() override;
+    virtual PrinterInfo GetSystemDefaultPrinter() override;
+    virtual bool PrintDirect(const std::string &printerName, const std::vector<uint8_t> &data, const std::string &dataType) override;
+    virtual PrinterInfo GetStatusPrinter(const std::string &printerName) override;
+};
+
+#endif

package/.gitattributes

@@ -1,2 +0,0 @@
-# Auto detect text files and perform LF normalization
-* text=auto

package/Gruntfile.js

@@ -1,80 +0,0 @@
-module.exports = function(grunt) {
-    grunt.initConfig({
-        shell: {
-            'node-pre-gyp-ia32': {
-                command: 'node-pre-gyp configure build package --target_arch=ia32'
-            },
-            'node-pre-gyp-x64': {
-                command: 'node-pre-gyp configure build package --target_arch=x64'
-            },
-            'node-gyp-ia32': {
-                command: 'node-gyp rebuild --arch=ia32'
-            },
-            'node-gyp-x64': {
-                command: 'node-gyp rebuild --arch=x64'
-            },
-            'upload-binaries': {
-                command: 'node-pre-gyp-github publish'
-            }
-        },
-        copy: {
-            ia32: {
-                files: [
-                    {src: 'build/Release/electron-printer.node', dest: 'lib/electron-printer-' + process.platform + '-ia32.node'},
-                    {src: 'binding.js', dest: 'lib/binding.js'},
-                    {src: 'index.js', dest: 'lib/index.js'}
-                ]
-            },
-            x64: {
-                files: [
-                    {src: 'build/Release/electron-printer.node', dest: 'lib/electron-printer-' + process.platform + '-x64.node'},
-                    {src: 'binding.js', dest: 'lib/binding.js'},
-                    {src: 'index.js', dest: 'lib/index.js'}
-                ]
-            }
-        }
-    });
-
-    grunt.loadNpmTasks('grunt-contrib-jshint');
-    grunt.loadNpmTasks('grunt-shell');
-    grunt.loadNpmTasks('grunt-contrib-copy');
-
-    grunt.registerTask('build-pre-ia32', [
-        'shell:node-pre-gyp-ia32',
-        'copy:ia32'
-    ]);
-
-    grunt.registerTask('build-ia32', [
-        'shell:node-gyp-ia32',
-        'copy:ia32'
-    ]);
-
-    grunt.registerTask('build-x64', [
-        'shell:node-gyp-x64',
-        'copy:x64'
-    ]);
-
-    grunt.registerTask('build-pre-x64', [
-        'shell:node-pre-gyp-x64',
-        'copy:x64'
-    ]);
-
-    grunt.registerTask('build', [
-        'build-ia32',
-        'build-x64'
-    ]);
-
-    grunt.registerTask('build-pre', [
-        'build-pre-ia32',
-        'build-pre-x64'
-    ]);
-
-    grunt.registerTask('upload', [
-        'shell:upload-binaries'
-    ]);
-
-    grunt.registerTask('release', [
-        'build-pre',
-        'upload'
-    ]);
-};

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 MOHAMMED ESSLASSI
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/binding.js

@@ -1,244 +0,0 @@
-const path = require('path');
-const os = require('os');
-let addon = {}, binary_path;
-switch (os.platform()) {
-    case 'win32':
-        if (os.arch() === 'ia32') {
-            binary_path = path.join(__dirname, 'electron-printer.node');
-        } else if (os.arch() === 'x64') {
-            binary_path = path.join(__dirname, 'electron-printer.node');
-        }
-        addon = require(binary_path);
-        break;
-    case 'darwin':
-        binary_path = path.join(__dirname, 'electron-printer.node'); 
-        addon = require(binary_path);
-        break;
-    case 'linux':
-        if (os.arch() === 'ia32') {
-            addon = path.join(__dirname, 'electron-printer.node');
-        } else if (os.arch() === 'x64') {
-            addon = path.join(__dirname, 'electron-printer.node');
-        }
-        break;
-    default:
-        binary_path = path.join(__dirname, 'electron-printer.node'); 
-        addon = require(binary_path);
-}
-
-module.exports.sayMyName = addon.SayMyName
-module.exports.getPrinters = addon.getPrinters
-module.exports.printDirect = printDirect
-module.exports.getDefaultPrinterName = addon.getDefaultPrinterName
-module.exports.getPrinter = getPrinter;
-/// send file to printer
-module.exports.printFile = printFile;
-/** Get supported print format for printDirect
- */
-module.exports.getSupportedPrintFormats = addon.getSupportedPrintFormats;
-/*
- print raw data. This function is intend to be asynchronous
-
- parameters:
- parameters - Object, parameters objects with the following structure:
- data - String, mandatory, data to printer
- printer - String, optional, name of the printer, if missing, will try to print to default printer
- docname - String, optional, name of document showed in printer status
- type - String, optional, only for wind32, data type, one of the RAW, TEXT
- options - JS object with CUPS options, optional
- success - Function, optional, callback function
- error - Function, optional, callback function if exists any error
-
- or
-
- data - String, mandatory, data to printer
- printer - String, optional, name of the printer, if missing, will try to print to default printer
- docname - String, optional, name of document showed in printer status
- type - String, optional, data type, one of the RAW, TEXT
- options - JS object with CUPS options, optional
- success - Function, optional, callback function with first argument job_id
- error - Function, optional, callback function if exists any error
- */
- function printDirect(parameters){
-    var data = parameters
-        , printer
-        , docname
-        , type
-        , options
-        , success
-        , error;
-
-    if(arguments.length==1){
-        //TODO: check parameters type
-        //if (typeof parameters )
-        data = parameters.data;
-        printer = parameters.printer;
-        docname = parameters.docname;
-        type = parameters.type;
-        options = parameters.options||{};
-        success = parameters.success;
-        error = parameters.error;
-    }else{
-        printer = arguments[1];
-        type = arguments[2];
-        docname = arguments[3];
-        options = arguments[4];
-        success = arguments[5];
-        error = arguments[6];
-    }
-
-    if(!type){
-        type = "RAW";
-    }
-
-    // Set default printer name
-    if(!printer) {
-        printer = addon.getDefaultPrinterName();
-    }
-
-    type = type.toUpperCase();
-
-    if(!docname){
-        docname = "node print job";
-    }
-
-    if (!options){
-        options = {};
-    }
-
-    //TODO: check parameters type
-    if(addon.printDirect){// call C++ binding
-        try{
-            var res = addon.printDirect(data, printer, docname, type, options);
-            if(res){
-                success(res);
-            }else{
-                error(Error("Something wrong in printDirect"));
-            }
-        }catch (e){
-            error(e);
-        }
-    }else{
-        error("Not supported");
-    }
-}
-
-/** Get printer info with jobs
- * @param printerName printer name to extract the info
- * @return printer object info:
- *		TODO: to enum all possible attributes
- */
- function getPrinter(printerName)
- {
-     if(!printerName) {
-         printerName = addon.getDefaultPrinterName();
-     }
-     var printer = addon.getPrinter(printerName);
-     correctPrinterinfo(printer);
-     return printer;
- }
-
-
-function correctPrinterinfo(printer) {
-    if(printer.status || !printer.options || !printer.options['printer-state']){
-        return;
-    }
-
-    var status = printer.options['printer-state'];
-    // Add posix status
-    if(status == '3'){
-        status = 'IDLE'
-    }
-    else if(status == '4'){
-        status = 'PRINTING'
-    }
-    else if(status == '5'){
-        status = 'STOPPED'
-    }
-
-    // correct date type
-    var k;
-    for(k in printer.options) {
-        if(/time$/.test(k) && printer.options[k] && !(printer.options[k] instanceof Date)) {
-            printer.options[k] = new Date(printer.options[k] * 1000);
-        }
-    }
-
-    printer.status = status;
-}
-
-/**
-parameters:
-   parameters - Object, parameters objects with the following structure:
-      filename - String, mandatory, data to printer
-      docname - String, optional, name of document showed in printer status
-      printer - String, optional, mane of the printer, if missed, will try to retrieve the default printer name
-      success - Function, optional, callback function
-      error - Function, optional, callback function if exists any error
-*/
-function printFile(parameters){
-    var filename,
-        docname,
-        printer,
-        options,
-        success,
-        error;
-
-    if((arguments.length !== 1) || (typeof(parameters) !== 'object')){
-        throw new Error('must provide arguments object');
-    }
-
-    filename = parameters.filename;
-    docname = parameters.docname;
-    printer = parameters.printer;
-    options = parameters.options || {};
-    success = parameters.success;
-    error = parameters.error;
-
-    if(!success){
-        success = function(){};
-    }
-
-    if(!error){
-        error = function(err){
-            throw err;
-        };
-    }
-
-    if(!filename){
-        var err = new Error('must provide at least a filename');
-        return error(err);
-    }
-
-    // try to define default printer name
-    if(!printer) {
-        printer = addon.getDefaultPrinterName();
-    }
-
-    if(!printer) {
-        return error(new Error('Printer parameter of default printer is not defined'));
-    }
-
-    // set filename if docname is missing
-    if(!docname){
-        docname = filename;
-    }
-
-    //TODO: check parameters type
-    if(addon.printFile){// call C++ binding
-        try{
-            // TODO: proper success/error callbacks from the extension
-            var res = addon.printFile(filename, docname, printer, options);
-
-            if(!isNaN(parseInt(res))) {
-                success(res);
-            } else {
-                error(Error(res));
-            }
-        } catch (e) {
-            error(e);
-        }
-    } else {
-        error("Not supported");
-    }
-}

package/index.js

@@ -1 +0,0 @@
-module.exports = require('./binding');

package/printer.js

@@ -1 +0,0 @@
-module.exports = require('./lib/binding');

package/src/hello_world.cc

@@ -1,8 +0,0 @@
-#include "node_printer.hpp"
-
-MY_NODE_MODULE_CALLBACK(SayMyName) 
-{
-  MY_NODE_MODULE_HANDLESCOPE
-   Napi::String result = Napi::String::New(info.Env(), "Hello, From C++ !");
-  MY_NODE_MODULE_RETURN_VALUE(result);
-}

package/src/macros.hh

@@ -1,53 +0,0 @@
-#ifndef NODE_PRINTER_SRC_MACROS_H
-#define NODE_PRINTER_SRC_MACROS_H
-#include <napi.h>
-
-
-#define MY_NODE_MODULE_ENV_DECL Napi::Env env = info.Env();
-#define MY_NODE_MODULE_ENV      env
-#define MY_NODE_MODULE_HANDLESCOPE MY_NODE_MODULE_ENV_DECL Napi::HandleScope scope(env);
-
-#define MY_MODULE_SET_METHOD(exports, name, method) \
-    (exports).Set(Napi::String::New(env, name), Napi::Function::New(env, method))
-
-#define MY_NODE_MODULE_CALLBACK(name) Napi::Value name(const Napi::CallbackInfo& info)
-
-#define MY_NODE_MODULE_RETURN_VALUE(value) \
-    return value;
-
-#define NAPI_STRING_NEW_UTF8(env, value) Napi::String::New(env, value)
-
-#define ADD_NAPI_NUMBER_PROPERTY(obj, name, value) \
-    obj.Set(Napi::String::New(obj.Env(), name), Napi::Number::New(obj.Env(), value))
-
-#define NAPI_STRING_NEW_2BYTES(env, value) Napi::String::New(env, (char16_t*)value)
-
-#define ADD_NAPI_STRING_PROPERTY(obj, name, key) \
-if ((job->key != NULL) && (*job->key != L'\0')) { \
-    obj.Set(Napi::String::New(obj.Env(), name), Napi::String::New(obj.Env(), (char16_t*)job->key)); \
-}
-
-#define RETURN_EXCEPTION(env, msg) \
-    Napi::Error::New(env, msg).ThrowAsJavaScriptException(); \
-    return env.Null(); // Ensure a Napi::Value is returned
-
-#define RETURN_EXCEPTION_STR(env, msg) \
-    RETURN_EXCEPTION(env, msg)
-
-#define REQUIRE_ARGUMENTS(env, args, n)                                                   \
-    if (args.Length() < (n)) {                                                 \
-        RETURN_EXCEPTION_STR(env, "Expected " #n " arguments");                       \
-    }
-
-#define ARG_CHECK_STRING(env, args, i)                                                   \
-    if ((args).Length() <= (i) || !(args)[(i)].IsString()) {                                                 \
-        RETURN_EXCEPTION_STR(env, "Argument " #i " must be a string");                       \
-    }
-
-#define REQUIRE_ARGUMENT_STRINGW(env, args, i, var)                                      \
-    ARG_CHECK_STRING(env, args, i);                                                      \
-    std::wstring var = (args)[(i)].As<Napi::String>().Utf16Value();
-
-
-#endif
-

package/src/node_printer.cc

@@ -1,31 +0,0 @@
-#include "node_printer.hpp"
-
-
-
-Napi::Object Init(Napi::Env env, Napi::Object exports) {
-  MY_MODULE_SET_METHOD(exports, "SayMyName",  SayMyName);
-  MY_MODULE_SET_METHOD(exports, "getPrinters", getPrinters);
-  MY_MODULE_SET_METHOD(exports, "getDefaultPrinterName", getDefaultPrinterName);
-  MY_MODULE_SET_METHOD(exports, "printDirect", printDirect); 
-  MY_MODULE_SET_METHOD(exports, "getPrinter", getPrinter);
-  MY_MODULE_SET_METHOD(exports, "printFile", printFile);
-  MY_MODULE_SET_METHOD(exports, "getSupportedPrintFormats", getSupportedPrintFormats);
-  return exports;
-}
-
-NODE_API_MODULE(addon, Init)
-
-// Helpers
-
-bool getStringOrBufferFromNapiValue(const Napi::Value& value, std::string& oData) {
-    if (value.IsString()) {
-        oData = value.As<Napi::String>().Utf8Value();
-        return true;
-    }
-    if (value.IsBuffer()) {
-        Napi::Buffer<char> buffer = value.As<Napi::Buffer<char>>();
-        oData.assign(buffer.Data(), buffer.Length());
-        return true;
-    }
-    return false;
-}