Automatizar el uso de Bullzip PDF Printer

[Angel.Matilla]

Tengo instalado este programa para cuando necesito imprimir en formato PDF y me gustaría que en un programa que estoy desarrollando si selecciono como destino esta impresora se automatizara el proceso sin necesidad de mostrar cuadros de diálogo y demás. Lo malo es que el único código aparentemente completo que he encontrado está en VBA y no tengo ni idea de como funciona. ¿Alguno puede ayudarme con la traducción?

Sub ImprimirAut()
Dim objPrinterSettings As Object
Set objPrinterSettings = CreateObject("Bullzip.PDFPrinterSettings")

' Configurar la ruta y nombre del archivo
objPrinterSettings.SetValue "Output", "C:\MisDocumentos\ArchivoAutomatico.pdf"

' Desactivar todas las ventanas emergentes
objPrinterSettings.SetValue "ShowSaveAs", "never"
objPrinterSettings.SetValue "ShowProgress", "no"
objPrinterSettings.SetValue "ShowProgressFinished", "no"
objPrinterSettings.SetValue "ShowPDF", "no" ' No abrir el PDF al terminar
objPrinterSettings.SetValue "ConfirmOverwrite", "no"

' Guardar la configuración (escribe el archivo runonce.ini automáticamente)
objPrinterSettings.WriteSettings True

' Enviar a imprimir desde tu aplicación asegurándote de usar Bullzip
' Ejemplo en Excel:
' ActiveSheet.PrintOut ActivePrinter:="Bullzip PDF Printer"
End Sub

Porque también lo he encontrado en C++, pero me parece que falta algo.

#include <windows.h>
#include <iostream>
#include <comdef.h>

// Reemplaza esta ruta por la localización real de tu archivo de configuración de Bullzip si fuese necesario.
// Sin embargo, instanciarlo por su ProgID ("Bullzip.PDFPrinterSettings") suele ser suficiente.

int main() {
    // 1. Inicializar el entorno COM de Windows
    HRESULT hr = CoInitialize(NULL);
    if (FAILED(hr)) {
        std::cerr << "Error al inicializar COM." << std::endl;
        return 1;
    }

    try {
        // 2. Obtener el CLSID a partir del ProgID de Bullzip
        CLSID clsid;
        hr = CLSIDFromProgID(L"Bullzip.PDFPrinterSettings", &clsid);
        if (FAILED(hr)) {
            throw std::runtime_error("No se encontró el componente COM de Bullzip. ¿Está instalado?");
        }

        // 3. Crear la instancia del objeto de configuración
        IDispatch* pBullzipSettings = nullptr;
        hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, IID_IDispatch, (void**)&pBullzipSettings);
        if (FAILED(hr)) {
            throw std::runtime_error("No se pudo crear la instancia de Bullzip Settings.");
        }

        // Helper Lambda para invocar métodos (SetValue, WriteSettings) mediante IDispatch
        auto invokeMethod = [](IDispatch* obj, OLECHAR* name, VARIANT* args, int argCount) -> _variant_t {
            DISPID dispid;
            HRESULT hr = obj->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &dispid);
            if (FAILED(hr)) return _variant_t();

            DISPPARAMS params = { args, NULL, (UINT)argCount, 0 };
            _variant_t result;
            hr = obj->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &params, &result, NULL, NULL);
            return result;
        };

        // 4. Configurar los parámetros de impresión automática
        // Nota: Los argumentos en Invoke se pasan en orden inverso (derecha a izquierda)
        
        // Parámetro: Output -> Ruta donde se guardará el PDF
        VARIANT argsOutput[2];
        argsOutput[1].vt = VT_BSTR; argsOutput[1].bstrVal = SysAllocString(L"Output");
        argsOutput[0].vt = VT_BSTR; argsOutput[0].bstrVal = SysAllocString(L"C:\\destino\\mi_documento.pdf");
        invokeMethod(pBullzipSettings, L"SetValue", argsOutput, 2);
        SysFreeString(argsOutput[1].bstrVal); SysFreeString(argsOutput[0].bstrVal);

        // Parámetro: ShowPDF -> "no" (Evita que se abra el lector de PDF tras crear el archivo)
        VARIANT argsShow[2];
        argsShow[1].vt = VT_BSTR; argsShow[1].bstrVal = SysAllocString(L"ShowPDF");
        argsShow[0].vt = VT_BSTR; argsShow[0].bstrVal = SysAllocString(L"no");
        invokeMethod(pBullzipSettings, L"SetValue", argsShow, 2);
        SysFreeString(argsShow[1].bstrVal); SysFreeString(argsShow[0].bstrVal);

        // Parámetro: ShowSettings -> "never" (Oculta por completo la interfaz gráfica de Bullzip)
        VARIANT argsShowSettings[2];
        argsShowSettings[1].vt = VT_BSTR; argsShowSettings[1].bstrVal = SysAllocString(L"ShowSettings");
        argsShowSettings[0].vt = VT_BSTR; argsShowSettings[0].bstrVal = SysAllocString(L"never");
        invokeMethod(pBullzipSettings, L"SetValue", argsShowSettings, 2);
        SysFreeString(argsShowSettings[1].bstrVal); SysFreeString(argsShowSettings[0].bstrVal);

        // Parámetro: ConfirmOverwrite -> "no" (Sobrescribe de forma automática si el archivo ya existe)
        VARIANT argsOverwrite[2];
        argsOverwrite[1].vt = VT_BSTR; argsOverwrite[1].bstrVal = SysAllocString(L"ConfirmOverwrite");
        argsOverwrite[0].vt = VT_BSTR; argsOverwrite[0].bstrVal = SysAllocString(L"no");
        invokeMethod(pBullzipSettings, L"SetValue", argsOverwrite, 2);
        SysFreeString(argsOverwrite[1].bstrVal); SysFreeString(argsOverwrite[0].bstrVal);

        // 5. Confirmar y escribir la configuración en el archivo temporal 'runonce.ini'
        // El método WriteSettings acepta un booleano (true para escribir la configuración de inmediato)
        VARIANT argsWrite[1];
        argsWrite[0].vt = VT_BOOL; argsWrite[0].boolVal = VARIANT_TRUE;
        invokeMethod(pBullzipSettings, L"WriteSettings", argsWrite, 1);

        // 6. Liberar el objeto COM de configuración
        pBullzipSettings->Release();

        // 7. Lanzar la impresión real del documento usando la API de Windows
        // Esto envía el archivo a la cola de Bullzip, la cual procesará el runonce.ini que acabamos de crear.
        std::cout << "Configuración inyectada. Enviando archivo a 'Bullzip PDF Printer'..." << std::endl;
        
        // Ejemplo para mandar a imprimir un archivo de texto existente silenciosamente:
        ShellExecute(NULL, L"printto", L"C:\\origen\\documento.txt", L"\"Bullzip PDF Printer\"", NULL, SW_HIDE);

    } catch (const std::exception& e) {
        std::cerr << "Excepción: " << e.what() << std::endl;
    }

    // Cerrar el entorno COM
    CoUninitialize();
    return 0;
}

Hay por ahí un par de funciones (CoInitialize y CoUninitialize) que no han incluído en el código.

[Casimiro Noteví]

Pregunto, ¿tiene que ser ese programa?
Hay otros que puedes usar y funcionan perfectamente.
E incluso creo recordar que el propio windows ya permite instalar una impresora pdf directamente.

[emailx45]

Try this: (CONSOLE for tests... )

Código Delphi [-]
program ConverterBullzipCom;

{$APPTYPE CONSOLE}

uses
  System.SysUtils,
  System.Variants,
  Winapi.Windows,
  Winapi.ShellAPI,
  System.Win.ComObj,
  Winapi.Ole2;

procedure ExecutarAutomacaoBullzip;
var
  LBullzipSettings: OleVariant;
  LPrinterName    : string;
  LArquivoOrigem  : string;
  LRetorno        : NativeInt;
begin
  // 1. Inicializa COM (Delphi ya gestiona CoInitialize implícitamente al instanciar OleVariant,
  // pero podemos asegurarlo llamándolo si es necesario).
  CoInitialize( nil );
  try
    try
      // 2. Crea la instancia del objeto COM de Bullzip a partir del ProgID
      LBullzipSettings := CreateOleObject( 'Bullzip.PDFPrinterSettings' );

      // 3. Configura los parámetros de impresión automática utilizando el método SetValue
      // Nota: En Delphi con OleVariant, la llamada a métodos con parámetros es directa.
      LBullzipSettings.SetValue( 'Output', 'C:\destino\mi_documento.pdf' );
      LBullzipSettings.SetValue( 'ShowPDF', 'no' );
      LBullzipSettings.SetValue( 'ShowSettings', 'never' );
      LBullzipSettings.SetValue( 'ConfirmOverwrite', 'no' );

      // 4. Guarda la configuración en el archivo 'runonce.ini' (equivalente a WriteSettings(true))
      LBullzipSettings.WriteSettings( True );

      // 5. Libera la referencia COM (asignando Unassigned)
      LBullzipSettings := Unassigned;

      Writeln( 'Configuração inyectada. Enviando arquivo para "Bullzip PDF Printer"...' );

      // 6. Define la impresora de destino y el archivo de origen
      LPrinterName   := 'Bullzip PDF Printer';
      LArquivoOrigem := 'C:\origen\documento.txt';

      // 7. Envía el archivo a la impresora usando ShellExecute con el verbo 'printto'
      LRetorno := ShellExecute( 0, 'printto', PChar( LArquivoOrigem ), PChar( LPrinterName ), nil, SW_HIDE );

      if LRetorno > 32 then
        Writeln( '¡Comando de impresión enviado con éxito!' )
      else
        Writeln( 'Error al enviar a imprimir. Código: ', LRetorno );

    except
      on E: Exception do
      begin
        Writeln( 'Excepción capturada: ', E.Message );
      end;
    end;
  finally
    CoUninitialize( );
  end;
end;

begin
  ExecutarAutomacaoBullzip;
  Writeln( 'Presiona ENTER para salir...' );
  Readln;

end.

[Angel.Matilla]

Empezado por Casimiro Noteví

Pregunto, ¿tiene que ser ese programa?
Hay otros que puedes usar y funcionan perfectamente.
E incluso creo recordar que el propio windows ya permite instalar una impresora pdf directamente.

No, puede ser cualquiera pero es el que llevo años utilizando y siempre me ha dado buen resultado.

Empezado por emailx45

Try this: (CONSOLE for tests... )

Muchas gracias por el esfuerzo, pero no era trasladarlo a Delphi. Eso se me olvidó ponerlo: era para C++.

[Casimiro Noteví]

Prueba el pdfcreator, está en nuestro ftp:
https://terawiki.clubdelphi.com/Delp...PdfCreator.zip
Eso crea una impresora virtual a donde puedes enviar todo lo que quieras imprimir a formato pdf.
La versión última de ese componente me temo que lo ha comprado una empresa y ahora e de pago, pero esa versión que está en nuestro ftp es la anterior que era gratis.
Y funciona perfectamente.

[Casimiro Noteví]

Y si necesitas código C++ para lo que te ha pasado en Delphi emailx45, pásaselo a cualquier IA y le indicas que te lo convierta al lenguaje que quieras.