Example #1
1
	// SendBytesToPrinter()
	// When the function is given a printer name and an unmanaged array
	// of bytes, the function sends those bytes to the print queue.
	// Returns true on success, false on failure.
	public static bool SendBytesToPrinter( string szPrinterName, IntPtr pBytes, Int32 dwCount)
	{
		Int32    dwError = 0, dwWritten = 0;
		IntPtr    hPrinter = new IntPtr(0);
		DOCINFOA    di = new DOCINFOA();
		bool    bSuccess = false; // Assume failure unless you specifically succeed.

		di.pDocName = "My C#.NET RAW Document";
		di.pDataType = "RAW";

		// Open the printer.
		if( OpenPrinter( szPrinterName, out hPrinter, 0 ) )
		{
			// Start a document.
			if( StartDocPrinter(hPrinter, 1, di) )
			{
				// Start a page.
				if( StartPagePrinter(hPrinter) )
				{
					// Write your bytes.
					bSuccess = WritePrinter(hPrinter, pBytes, dwCount, out dwWritten);
					EndPagePrinter(hPrinter);
				}
				EndDocPrinter(hPrinter);
			}
			ClosePrinter(hPrinter);
		}
		// If you did not succeed, GetLastError may give more information
		// about why not.
		if( bSuccess == false )
		{
			dwError = Marshal.GetLastWin32Error();
		}
		return bSuccess;
	}
Example #2
0
        // SendBytesToPrinter()
        // When the function is given a printer name and an unmanaged array
        // of bytes, the function sends those bytes to the print queue.
        // Returns true on success, false on failure.
        private static bool SendBytesToPrinter(string szPrinterName, IntPtr pBytes, Int32 dwCount)
        {
            Int32 dwError = 0, dwWritten = 0;
            IntPtr hPrinter = new IntPtr(0);
            DOCINFOA di = new DOCINFOA();
            bool bSuccess = false; // Assume failure unless you specifically succeed.

            di.pDocName = "Labels";
            di.pDataType = "RAW";

            if (OpenPrinter(szPrinterName.Normalize(), out hPrinter, IntPtr.Zero))
            {
                if (StartDocPrinter(hPrinter, 1, di))
                {
                    if (StartPagePrinter(hPrinter))
                    {
                        bSuccess = WritePrinter(hPrinter, pBytes, dwCount, out dwWritten);
                        EndPagePrinter(hPrinter);
                    }
                    EndDocPrinter(hPrinter);
                }
                ClosePrinter(hPrinter);
            }
            // If you did not succeed, GetLastError may give more information
            // about why not.
            if (bSuccess == false)
            {
                dwError = Marshal.GetLastWin32Error();
            }
            return bSuccess;
        }
Example #3
0
 public static bool SendBytesToPrinter(string szPrinterName, IntPtr pBytes, int dwCount)
 {
     IntPtr hPrinter = new IntPtr(0);
     DOCINFOA di = new DOCINFOA();
     bool flag = false;
     di.pDocName = "My C#.NET RAW Document";
     di.pDataType = "RAW";
     if (OpenPrinter(szPrinterName.ToString(), out hPrinter, IntPtr.Zero))
     {
         if (StartDocPrinter(hPrinter, 1, di))
         {
             if (StartPagePrinter(hPrinter))
             {
                 int dwWritten = 0;
                 flag = WritePrinter(hPrinter, pBytes, dwCount, out dwWritten);
                 EndPagePrinter(hPrinter);
             }
             EndDocPrinter(hPrinter);
         }
         ClosePrinter(hPrinter);
     }
     if (!flag)
     {
         Marshal.GetLastWin32Error();
     }
     return flag;
 }
Example #4
0
        private static bool SendBytesToPrinter(string printerName, string documentName, IntPtr data, Int32 length)
        {
            var printerHandle = new IntPtr(0);
            var documentInfo = new DOCINFOA();
            bool success = false;

            documentInfo.pDocName = documentName;
            documentInfo.pDataType = "RAW";

            if (OpenPrinter(printerName.Normalize(), out printerHandle, IntPtr.Zero))
            {
                if (StartDocPrinter(printerHandle, 1, documentInfo))
                {
                    if (StartPagePrinter(printerHandle))
                    {
                        Int32 dwWritten = 0;
                        success = WritePrinter(printerHandle, data, length, out dwWritten);
                        EndPagePrinter(printerHandle);
                    }

                    EndDocPrinter(printerHandle);
                }

                ClosePrinter(printerHandle);
            }

            Int32 dwError = 0;
            if (success == false) dwError = Marshal.GetLastWin32Error();

            return success;
        }
 public static bool SendBytesToPrinter(string szPrinterName, IntPtr pBytes, int dwCount)
 {
     int dwError = 0;int dwWritten = 0;IntPtr hPrinter = new IntPtr(0);
     DOCINFOA di = new DOCINFOA();
     bool bSuccess = false;
     di.pDocName = "My C#.NET RAW Document";
     di.pDataType = "RAW";
     if (OpenPrinter(szPrinterName.Normalize(), out hPrinter, IntPtr.Zero))
     {
         if (StartDocPrinter(hPrinter, 1, di))
         {
             if (StartPagePrinter(hPrinter))
             {
                 bSuccess = WritePrinter(hPrinter, pBytes, dwCount, out dwWritten);
                 EndPagePrinter(hPrinter);
             }
             EndDocPrinter(hPrinter);
         }
         ClosePrinter(hPrinter);
     }
     if (!bSuccess)
     {
         dwError = Marshal.GetLastWin32Error();
     }
     return bSuccess;
 }
Example #6
0
 public static IntPtr GetPrinter(string szPrinterName)
 {
     var di = new DOCINFOA { pDocName = "Samba POS Document", pDataType = "RAW" };
     IntPtr hPrinter;
     if (!OpenPrinter(szPrinterName, out hPrinter, IntPtr.Zero)) BombWin32();
     if (!StartDocPrinter(hPrinter, 1, di)) BombWin32();
     if (!StartPagePrinter(hPrinter)) BombWin32();
     return hPrinter;
 }
Example #7
0
        public static bool SendBytesToPrinter(string szPrinterName, IntPtr pBytes,
        Int32 dwCount)
        {

            Int32 dwError = 0, dwWritten = 0;

            IntPtr hPrinter = new IntPtr(0);

            DOCINFOA di = new DOCINFOA();

            bool bSuccess = false; // Assume failure unless you specifically succeed.

            di.pDocName = "My C#.NET RAW Document";

            di.pDataType = "RAW";

            if (OpenPrinter(szPrinterName, out hPrinter, 0))
            {

                if (StartDocPrinter(hPrinter, 1, di))
                {

                    if (StartPagePrinter(hPrinter))
                    {

                        bSuccess = WritePrinter(hPrinter, pBytes, dwCount, out dwWritten);

                        EndPagePrinter(hPrinter);

                    }

                    EndDocPrinter(hPrinter);

                }

                ClosePrinter(hPrinter);

            }

            if (bSuccess == false)
            {

                dwError = GetLastError();

            }

            return bSuccess;

        }
  // SendBytesToPrinter()
  // When the function is given a printer name and an unmanaged array
  // of bytes, the function sends those bytes to the print queue.
  // Returns true on success, false on failure.
  public static bool SendBytesToPrinter(string szPrinterName, IntPtr pBytes, Int32 dwCount)
  {
    IntPtr hPrinter;
    var di = new DOCINFOA();
    var bSuccess = false; // Assume failure unless you specifically succeed.

    di.pDocName = Assembly.GetExecutingAssembly().GetName().Name + " Document";
    //di.pDataType = "RAW"; //leaving this null means it can be specified at the printer definition...
    //this facilitates having RAW for the true Epson printer and TEXT for the Generic / Text Only printer
    //for whatever reason the Generic printer will only print to "FILE:" when the TEXT "print processor" has been chosen
    //(under Control Panel > Printers > your printer > Printer properties > Advanced > Print processor)
    //and print to file is simply a convenient way to check that the basic print logic is working w/o wasting paper
    //what's even more whacked out is that when you do print to file, on Win7, the "Interactive Services Detection" will popup
    //to provide the GUI for entering the filename to output to
    //references: http://blogs.msdn.com/b/patricka/archive/2010/04/27/what-is-interactive-services-detection-and-why-is-it-blinking-at-me.aspx
    //http://s309.codeinspot.com/q/1071364

    // Open the printer.
    if (OpenPrinter(szPrinterName.Normalize(), out hPrinter, IntPtr.Zero))
    {
      // Start a document.
      if (StartDocPrinter(hPrinter, 1, di))
      {
        // Start a page.
        if (StartPagePrinter(hPrinter))
        {
          // Write your bytes.
          int dwWritten;
          bSuccess = WritePrinter(hPrinter, pBytes, dwCount, out dwWritten);
          EndPagePrinter(hPrinter);
        }
        EndDocPrinter(hPrinter);
      }
      ClosePrinter(hPrinter);
    }
    // If you did not succeed, GetLastError may give more information
    // about why not.
    if (bSuccess == false)
    {
      Marshal.GetLastWin32Error();
    }
    return bSuccess;
  }
Example #9
0
        public static bool DoAllNoInit(string szPrinterName)
        {
            Int32    dwError = 0, dwWritten = 0, dwWritten1 = 0, dwWritten2 = 0;
            IntPtr   hPrinter  = new IntPtr(0);
            DOCINFOA di        = new DOCINFOA();
            bool     bSuccess  = false;
            bool     bSuccess1 = false;
            bool     bSuccess2 = false;


            di.pDocName  = "DoAllNoInit";
            di.pDataType = "RAW";
            if (OpenPrinter(szPrinterName, out hPrinter, 0))
            {
                if (StartDocPrinter(hPrinter, 1, di))
                {
                    if (StartPagePrinter(hPrinter))
                    {
                        //int nLength;
                        int nLength1;
                        int nLength2;


                        char   V           = '@';
                        char   V1          = 'V';
                        byte[] DrawerOpen  = { 0x1d, Convert.ToByte(V) };
                        byte[] DrawerOpen1 = { 0x1d, Convert.ToByte(V), 66, 0 };
                        byte[] DrawerOpen2 = { 0x1B, 0x70, 0x0, 60, 120 };


                        //nLength = DrawerOpen.Length;
                        nLength1 = DrawerOpen1.Length;
                        nLength2 = DrawerOpen2.Length;


                        //IntPtr p = Marshal.AllocCoTaskMem(nLength);
                        IntPtr p1 = Marshal.AllocCoTaskMem(nLength1);
                        IntPtr p2 = Marshal.AllocCoTaskMem(nLength2);


                        //Marshal.Copy(DrawerOpen, 0, p, nLength);
                        Marshal.Copy(DrawerOpen1, 0, p1, nLength1);
                        Marshal.Copy(DrawerOpen2, 0, p2, nLength2);



                        //bSuccess = WritePrinter(hPrinter, p, DrawerOpen.Length, out dwWritten);
                        bSuccess1 = WritePrinter(hPrinter, p1, DrawerOpen1.Length, out dwWritten1);
                        bSuccess2 = WritePrinter(hPrinter, p2, DrawerOpen2.Length, out dwWritten2);



                        EndPagePrinter(hPrinter);
                        //Marshal.FreeCoTaskMem(p);
                        Marshal.FreeCoTaskMem(p1);
                        Marshal.FreeCoTaskMem(p2);
                    }
                    EndDocPrinter(hPrinter);
                }
                ClosePrinter(hPrinter);
            }
            if (bSuccess == false)
            {
                dwError = GetLastError();
            }
            return(bSuccess);
        }
Example #10
0
        public static bool PrintMyOwn(string szPrinterName)
        {
            Int32 dwError = 0, dwWritten = 0;



            IntPtr hPrinter = new IntPtr(0);



            DOCINFOA di = new DOCINFOA();



            bool bSuccess = false;



            di.pDocName = "OpenDrawer";



            di.pDataType = "RAW";



            if (OpenPrinter(szPrinterName, out hPrinter, 0))
            {
                if (StartDocPrinter(hPrinter, 1, di))
                {
                    if (StartPagePrinter(hPrinter))
                    {
                        int nLength;



                        byte[] DrawerOpen = new byte[] { 07 };



                        nLength = DrawerOpen.Length;



                        IntPtr p = Marshal.AllocCoTaskMem(nLength);



                        Marshal.Copy(DrawerOpen, 0, p, nLength);



                        bSuccess = WritePrinter(hPrinter, p, DrawerOpen.Length, out dwWritten);



                        EndPagePrinter(hPrinter);



                        Marshal.FreeCoTaskMem(p);
                    }



                    EndDocPrinter(hPrinter);
                }



                ClosePrinter(hPrinter);
            }



            if (bSuccess == false)
            {
                dwError = GetLastError();
            }



            return(bSuccess);
        }
 public static extern bool StartDocPrinter(IntPtr hPrinter, Int32 level, DOCINFOA di);
Example #12
0
        public static bool ReadFromPrinter(string szPrinterName, IntPtr pBytes, Int32 dwCount)
        {
            // Read the data from the printer.
            Int32 dwError = 0;
            var hPrinter = new IntPtr(0);
            Int32 dwBytesRead = 0;
            var di = new DOCINFOA();
            int bSuccess = -1;

            // Open the printer.
            if (OpenPrinter(szPrinterName.Normalize(), out hPrinter, IntPtr.Zero))
            {
                // Start a document.
                if (StartDocPrinter(hPrinter, 1, di))
                {
                    // Start a page.
                    if (StartPagePrinter(hPrinter))
                    {
                        // read your bytes.
                        bSuccess = ReadPrinter(hPrinter, out pBytes, dwCount, out dwBytesRead);
                        EndPagePrinter(hPrinter);
                    }
                    EndDocPrinter(hPrinter);
                }
                ClosePrinter(hPrinter);
            }
            //If you did not succeed, GetLastError may give more information about why not.
            if (bSuccess != 0)
            {
                dwError = Marshal.GetLastWin32Error();
                return false;
            }
            return true;
        }
Example #13
0
 public static extern bool StartDocPrinter(IntPtr hPrinter, Int32 level, DOCINFOA di);
Example #14
0
        public static bool FullCut(string szPrinterName, byte i)
        {

            Int32 dwError = 0, dwWritten = 0;

            IntPtr hPrinter = new IntPtr(0);

            DOCINFOA di = new DOCINFOA();

            bool bSuccess = false;

            di.pDocName = "FullCut";

            di.pDataType = "RAW";

            if (OpenPrinter(szPrinterName, out hPrinter, 0))
            {

                if (StartDocPrinter(hPrinter, 1, di))
                {

                    if (StartPagePrinter(hPrinter))
                    {

                        int nLength;

                        //byte[] DrawerOpen = new byte[] { 27, 100, 51 };

                        byte[] DrawerOpen = new byte[] { i };
                        nLength = DrawerOpen.Length;

                        IntPtr p = Marshal.AllocCoTaskMem(nLength);

                        Marshal.Copy(DrawerOpen, 0, p, nLength);

                        bSuccess = WritePrinter(hPrinter, p, DrawerOpen.Length, out dwWritten);

                        EndPagePrinter(hPrinter);

                        Marshal.FreeCoTaskMem(p);

                    }

                    EndDocPrinter(hPrinter);

                }

                ClosePrinter(hPrinter);

            }

            if (bSuccess == false)
            {

                dwError = GetLastError();

            }

            return bSuccess;

        }
    private static void SendBytesToPrinter(string szPrinterName, IntPtr pBytes, int dwCount, DOCINFOA documentInfo, out int jobId)
    {
        jobId = 0;
        var dwWritten = 0;
        var success   = false;

        if (OpenPrinter(szPrinterName.Normalize(), out var hPrinter, IntPtr.Zero))
        {
            jobId = StartDocPrinter(hPrinter, 1, documentInfo);
            if (jobId > 0)
            {
                if (StartPagePrinter(hPrinter))
                {
                    success = WritePrinter(hPrinter, pBytes, dwCount, out dwWritten);
                    EndPagePrinter(hPrinter);
                }
                EndDocPrinter(hPrinter);
            }
            ClosePrinter(hPrinter);
        }
        // TODO: The other methods such as OpenPrinter also have return values. Check those?
        if (success == false)
        {
            var dwError = Marshal.GetLastWin32Error();
            throw new Exception($"Printing to PDF failed. Error code: {dwError}.");
        }
        if (dwWritten != dwCount)
        {
            throw new Exception("Printing to PDF failed. Could not write all bytes.");
        }
    }
Example #16
0
 private static extern int StartDocPrinter(IntPtr hPrinter, int level, [In, MarshalAs(UnmanagedType.LPStruct)] DOCINFOA di);
Example #17
0
        private static int SendBytesToPrinter(string szPrinterName, IntPtr pBytes, int dwCount, DOCINFOA documentInfo, out int jobId)
        {
            jobId = 0;
            var dwWritten = 0;
            var success   = false;

            if (OpenPrinter(szPrinterName.Normalize(), out var hPrinter, IntPtr.Zero))
            {
                jobId = StartDocPrinter(hPrinter, 1, documentInfo);
                if (jobId > 0)
                {
                    if (StartPagePrinter(hPrinter))
                    {
                        success = WritePrinter(hPrinter, pBytes, dwCount, out dwWritten);
                        EndPagePrinter(hPrinter);
                    }

                    EndDocPrinter(hPrinter);
                }

                ClosePrinter(hPrinter);
            }

            // TODO: The other methods such as OpenPrinter also have return values. Check those?

            if (success == false)
            {
                return(Marshal.GetLastWin32Error());
            }

            return(0);
        }
        // SendBytesToPrinter()
        // When the function is given a printer name and an unmanaged array
        // of bytes, the function sends those bytes to the print queue.
        // Returns true on success, false on failure.
        public static bool SendBytesToPrinter(string szPrinterName, string szDocumentName, IntPtr pBytes, Int32 dwCount, string printDataType = "RAW")
        {
            Int32 dwError = 0, dwWritten = 0;
            IntPtr hPrinter = new IntPtr(0);
            DOCINFOA di = new DOCINFOA();
            bool bSuccess = false; // Assume failure unless you specifically succeed.

            di.pDocName = szDocumentName;
            // List of Data Types
            // RAW
            // TEXT
            // RAW [FF appended]
            // RAW [FF auto]
            // NT EMF 1.00x
            di.pDataType = printDataType;

            // Open the printer.
            if (OpenPrinter(szPrinterName.Normalize(), out hPrinter, IntPtr.Zero))
            {
                // Start a document.
                if (StartDocPrinter(hPrinter, 1, di))
                {
                    // Start a page.
                    if (StartPagePrinter(hPrinter))
                    {
                        // Write your bytes.
                        bSuccess = WritePrinter(hPrinter, pBytes, dwCount, out dwWritten);
                        EndPagePrinter(hPrinter);
                    }
                    EndDocPrinter(hPrinter);
                }
                ClosePrinter(hPrinter);
            }
            // If you did not succeed, GetLastError may give more information
            // about why not.
            if (bSuccess == false)
            {
                dwError = Marshal.GetLastWin32Error();
            }
            return bSuccess;
        }
Example #19
0
 private static extern bool StartDocPrinter(IntPtr hPrinter, int level,
                                            [MarshalAs(UnmanagedType.LPStruct), In]
                                            DOCINFOA di);
 public static extern bool StartDocPrinter(
     IntPtr printer,
     int level,
     [In, MarshalAs(UnmanagedType.LPStruct)] DOCINFOA documentInfo);
Example #21
0
    private static bool SendBytesToPrinter(string szPrinterName, IntPtr pBytes, int dwCount, DOCINFOA documentInfo)
    {
        var dwWritten = 0;
        var success   = false;

        if (OpenPrinter(szPrinterName.Normalize(), out var hPrinter, IntPtr.Zero))
        {
            if (StartDocPrinter(hPrinter, 1, documentInfo))
            {
                if (StartPagePrinter(hPrinter))
                {
                    success = WritePrinter(hPrinter, pBytes, dwCount, out dwWritten);
                    EndPagePrinter(hPrinter);
                }
                EndDocPrinter(hPrinter);
            }
            ClosePrinter(hPrinter);
        }
        // If print did not succeed, GetLastError may give more information about the failure.
        if (success == false)
        {
            var dwError = Marshal.GetLastWin32Error();
            throw new Exception($"Printing to PDF failed. Error code: {dwError}.");
        }
        return(success);
    }
Example #22
0
        public static bool FullCut(string szPrinterName)
        {
            Int32 dwError = 0, dwWritten = 0;



            IntPtr hPrinter = new IntPtr(0);



            DOCINFOA di = new DOCINFOA();



            bool bSuccess = false;



            di.pDocName = "FullCut";



            di.pDataType = "RAW";



            if (OpenPrinter(szPrinterName, out hPrinter, 0))
            {
                if (StartDocPrinter(hPrinter, 1, di))
                {
                    if (StartPagePrinter(hPrinter))
                    {
                        int nLength;



                        //byte[] DrawerOpen = new byte[] { 27, 100, 51 };

                        char   V          = 'V';
                        byte[] DrawerOpen = { 0x1d, Convert.ToByte(V), 66, 0 };



                        nLength = DrawerOpen.Length;



                        IntPtr p = Marshal.AllocCoTaskMem(nLength);



                        Marshal.Copy(DrawerOpen, 0, p, nLength);



                        bSuccess = WritePrinter(hPrinter, p, DrawerOpen.Length, out dwWritten);



                        EndPagePrinter(hPrinter);



                        Marshal.FreeCoTaskMem(p);
                    }



                    EndDocPrinter(hPrinter);
                }



                ClosePrinter(hPrinter);
            }



            if (bSuccess == false)
            {
                dwError = GetLastError();
            }



            return(bSuccess);
        }
Example #23
0
 public static extern bool StartDocPrinter(IntPtr hPrinter, Int32 level, [In, MarshalAs(UnmanagedType.LPStruct)] DOCINFOA di);
Example #24
0
        public bool Open(string DocName)
        {
            // see if printer is already open
             if(HandlePrinter!=IntPtr.Zero) return false;

             // opens the printer
             bool risp = OpenPrinter(ps.PrinterName,out HandlePrinter,IntPtr.Zero);
             if(risp==false) return false;

             // starts a print job
             DOCINFOA MyDocInfo = new DOCINFOA();
             MyDocInfo.pDocName = DocName;
             MyDocInfo.pOutputFile = null;
             MyDocInfo.pDataType = "RAW";

             if(StartDocPrinter(HandlePrinter, 1, MyDocInfo))
             {
            StartPagePrinter(HandlePrinter); //starts a page
            return true;
             }
             else return false;
        }
Example #25
0
        public static bool SendBytesToPrinter(string szPrinterName, IntPtr pBytes, Int32 dwCount, string Nom_Producto)
        {
            Int32 dwError = 0, dwWritten = 0;
            IntPtr hPrinter = new IntPtr(0);
            DOCINFOA di = new DOCINFOA();
            bool bSuccess = false;

            di.pDocName = "Etiqueta " + Nom_Producto;
            di.pDataType = "RAW";

            // Abra la impresora.
            if (OpenPrinter(szPrinterName.Normalize(), out hPrinter, IntPtr.Zero))
            {
                // Inicie un documento.
                if (StartDocPrinter(hPrinter, 1, di))
                {
                    // Inicia página.
                    if (StartPagePrinter(hPrinter))
                    {
                        // Escribe(Imprime).
                        bSuccess = WritePrinter(hPrinter, pBytes, dwCount, out dwWritten);
                        EndPagePrinter(hPrinter);
                    }
                    EndDocPrinter(hPrinter);
                }
                ClosePrinter(hPrinter);
            }
            if (bSuccess == false)
            {
                dwError = Marshal.GetLastWin32Error();
                Util.ShowError("Error al conectar a la impresora " + szPrinterName);
            }
            return bSuccess;
        }
    public static byte[] ReadBytesFromPrinter(string szPrinterName, byte[] statusRequest)
    {
        bool   bSuccess  = false;
        IntPtr hPrinter  = new IntPtr(0);
        IntPtr hPrintJob = new IntPtr(0);

        byte[] status = new byte[0];
        // Open the printer.
        if (OpenPrinter(szPrinterName.Normalize(), out hPrinter, IntPtr.Zero))
        {
            // Start a document.
            DOCINFOA di = new DOCINFOA()
            {
                pDocName = "Read RAW PrintDocument", pDataType = "RAW"
            };
            Int32 jobId = StartDocPrinter(hPrinter, 1, di);
            if (jobId > 0)
            {
                // We can't read from a printer handle, but we can read from a printer job handle,
                // So the trick is to create a Job using StartDocPrinter, then open a handle to the printer job...
                string jobName = string.Format("{0}, Job {1}", szPrinterName, jobId);
                if (OpenPrinter(jobName.Normalize(), out hPrintJob, IntPtr.Zero))
                {
                    // Start a page and print the Status-Request Sequence
                    if (StartPagePrinter(hPrinter))
                    {
                        {
                            Int32  dwCount        = statusRequest.Length;
                            IntPtr pStatusRequest = Marshal.AllocCoTaskMem(dwCount);
                            Marshal.Copy(statusRequest, 0, pStatusRequest, dwCount);
                            Int32 dwWritten = 0;

                            bSuccess = WritePrinter(hPrinter, pStatusRequest, dwCount, out dwWritten);

                            EndPagePrinter(hPrinter);
                            EndDocPrinter(hPrinter);                        // EndPage and EndDoc here, otherwise ReadPrinter ist always null

                            Marshal.FreeCoTaskMem(pStatusRequest);
                        }
                        if (bSuccess)
                        {
                            //read request from "Job Handle"
                            Int32  bufLen    = 32;
                            IntPtr pStatus   = Marshal.AllocCoTaskMem(bufLen);
                            Int32  statusLen = 0;

                            bSuccess = ReadPrinter(hPrintJob, pStatus, bufLen, out statusLen);

                            int err = Marshal.GetLastWin32Error();          // Sometimes is error 0x3F : Your file waiting to be printed was deleted.

                            status = new byte[statusLen];
                            if (statusLen > 0)
                            {
                                Marshal.Copy(pStatus, status, 0, statusLen);
                            }
                            Marshal.FreeCoTaskMem(pStatus);
                        }
                    }
                    ClosePrinter(hPrintJob);
                }
            }
            ClosePrinter(hPrinter);
        }
        return(status);
    }
        /// <summary>
        /// This function gets the printer name and an unmanaged array of bytes, the function sends those bytes to the print queue.
        /// </summary>
        /// <param name="szPrinterName">Printer Name</param>
        /// <param name="pBytes">No. of bytes in the pdf file</param>
        /// <param name="dwCount">Word count</param>
        /// <returns>True on success, false on failure</returns>
        private static bool SendBytesToPrinter(string szPrinterName, IntPtr pBytes, Int32 dwCount)
        {
            try
            {
                Int32 dwError = 0, dwWritten = 0;
                IntPtr hPrinter = new IntPtr(0);
                DOCINFOA di = new DOCINFOA();
                bool success = false; // Assume failure unless you specifically succeed.

                di.pDocName = "PDF Document";
                di.pDataType = "RAW";

                // Open the printer.
                if (OpenPrinter(szPrinterName.Normalize(), out hPrinter, IntPtr.Zero))
                {
                    // Start a document.
                    if (StartDocPrinter(hPrinter, 1, di))
                    {
                        // Start a page.
                        if (StartPagePrinter(hPrinter))
                        {
                            // Write the bytes.
                            success = WritePrinter(hPrinter, pBytes, dwCount, out dwWritten);
                            EndPagePrinter(hPrinter);
                        }
                        EndDocPrinter(hPrinter);
                    }
                    ClosePrinter(hPrinter);
                }

                // If print did not succeed, GetLastError may give more information about the failure.
                if (success == false)
                {
                    dwError = Marshal.GetLastWin32Error();
                }
                return success;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
Example #28
0
        /// <summary>
        /// Sends the bytes to printer.
        /// </summary>
        /// <param name="szPrinterName">Name of the sz printer.</param>
        /// <param name="pBytes">The p bytes.</param>
        /// <param name="dwCount">The dw count.</param>
        /// <returns></returns>
        public static bool SendBytesToPrinter(
            string szPrinterName,
            IntPtr pBytes,
            Int32 dwCount)
        {
            Int32 dwError = 0, dwWritten = 0;

            var hPrinter = new IntPtr(0);

            var di = new DOCINFOA();

            bool bSuccess = false;

            di.pDocName = "QWFP - Print Nomor Antrian";

            di.pDataType = "RAW";

            if (OpenPrinter(
                szPrinterName.Normalize(),
                out hPrinter, IntPtr.Zero))
            {
                if (StartDocPrinter(hPrinter, 1, di))
                {
                    if (StartPagePrinter(hPrinter))
                    {
                        bSuccess =
                            WritePrinter(
                                hPrinter,
                                pBytes,
                                dwCount,
                                out dwWritten);

                        EndPagePrinter(hPrinter);
                    }

                    EndDocPrinter(hPrinter);
                }

                ClosePrinter(hPrinter);
            }

            if (bSuccess == false)
            {
                dwError =
                    Marshal.GetLastWin32Error();
            }

            return bSuccess;
        }
Example #29
0
        public static void PrintXpsToPdf(byte[] bytes, string outputFilePath, string documentTitle)
        {
            // Get Microsoft Print to PDF print queue
            var pdfPrintQueue = GetMicrosoftPdfPrintQueue();

            // Copy byte array to unmanaged pointer
            var ptrUnmanagedBytes = Marshal.AllocCoTaskMem(bytes.Length);

            Marshal.Copy(bytes, 0, ptrUnmanagedBytes, bytes.Length);

            // Prepare document info
            var di = new DOCINFOA
            {
                pDocName    = documentTitle,
                pOutputFile = outputFilePath,
                pDataType   = "RAW"
            };

            // Print to PDF
            var errorCode = SendBytesToPrinter(pdfPrintQueue.Name, ptrUnmanagedBytes, bytes.Length, di, out var jobId);

            // Free unmanaged memory
            Marshal.FreeCoTaskMem(ptrUnmanagedBytes);

            // Check if job in error state (for example not enough disk space)
            var jobFailed = false;

            try
            {
                var pdfPrintJob = pdfPrintQueue.GetJob(jobId);
                if (pdfPrintJob.IsInError)
                {
                    jobFailed = true;
                    pdfPrintJob.Cancel();
                }
            }
            catch
            {
                // If job succeeds, GetJob will throw an exception. Ignore it.
            }
            finally
            {
                pdfPrintQueue.Dispose();
            }

            if (errorCode > 0 || jobFailed)
            {
                try
                {
                    if (File.Exists(outputFilePath))
                    {
                        File.Delete(outputFilePath);
                    }
                }
                catch
                {
                    // ignored
                }
            }

            if (errorCode > 0)
            {
                throw new Exception($"Printing to PDF failed. Error code: {errorCode}.");
            }

            if (jobFailed)
            {
                throw new Exception("PDF Print job failed.");
            }
        }
        //--------------------------------------------------------------------//
        //                                                        M e t h o d //
        // s e n d D a t a                                                    //
        //--------------------------------------------------------------------//
        //                                                                    //
        // Send data in provided stream to specified printer port.            //
        //                                                                    //
        //--------------------------------------------------------------------//

        public static Int32 sendData(BinaryReader prnReader,
                                     String printerName)
        {
            Int32 result    = 0;
            Int32 dwError   = 0,
                  dwWritten = 0;

            IntPtr hPrinter = new IntPtr(0);

            DOCINFOA di = new DOCINFOA();

            Boolean bSuccess = true;

            di.pDocName = "PCLParaphernalia RAW Document";

            //----------------------------------------------------------------//
            //                                                                //
            // Open the printer.                                              //
            //                                                                //
            //----------------------------------------------------------------//

            if (OpenPrinter(printerName.Normalize(),
                            out hPrinter,
                            IntPtr.Zero))
            {
                //------------------------------------------------------------//
                //                                                            //
                // Check if XPS printer driver or not                         //
                //                                                            //
                //------------------------------------------------------------//

                if (isDriverXPS(hPrinter))
                {
                    di.pDataType = "XPS_PASS";
                }
                else
                {
                    di.pDataType = "RAW";
                }

                //------------------------------------------------------------//
                //                                                            //
                // Start a document.                                          //
                //                                                            //
                //------------------------------------------------------------//

                if (StartDocPrinter(hPrinter, 1, di))
                {
                    //--------------------------------------------------------//
                    //                                                        //
                    // Start a page.                                          //
                    //                                                        //
                    //--------------------------------------------------------//

                    if (StartPagePrinter(hPrinter))
                    {
                        //----------------------------------------------------//
                        //                                                    //
                        // Read contents of supplied stream and send to       //
                        // windows printer.                                   //
                        //                                                    //
                        //----------------------------------------------------//

                        const Int32 bufLen = 512;

                        Int32 readLen;

                        Byte[] prnData = new Byte[bufLen];

                        prnReader.BaseStream.Position = 0;
                        prnData = prnReader.ReadBytes(bufLen);

                        while (((readLen = prnData.Length) != 0) && (bSuccess))
                        {
                            IntPtr pUnmanagedBytes = new IntPtr(0);

                            pUnmanagedBytes = Marshal.AllocCoTaskMem(readLen);

                            Marshal.Copy(prnData, 0, pUnmanagedBytes, readLen);

                            //------------------------------------------------//
                            //                                                //
                            // Send the unmanaged bytes to the printer.       //
                            //                                                //
                            //------------------------------------------------//

                            bSuccess = WritePrinter(hPrinter, pUnmanagedBytes,
                                                    readLen, out dwWritten);

                            prnData = prnReader.ReadBytes(bufLen);

                            //------------------------------------------------//
                            //                                                //
                            // Free the unmanaged memory and exit.            //
                            //                                                //
                            //------------------------------------------------//

                            Marshal.FreeCoTaskMem(pUnmanagedBytes);
                        }

                        //----------------------------------------------------//
                        //                                                    //
                        // End page.                                          //
                        //                                                    //
                        //----------------------------------------------------//

                        EndPagePrinter(hPrinter);
                    }

                    //--------------------------------------------------------//
                    //                                                        //
                    // End document.                                          //
                    //                                                        //
                    //--------------------------------------------------------//

                    EndDocPrinter(hPrinter);
                }

                //------------------------------------------------------------//
                //                                                            //
                // Close the printer.                                         //
                //                                                            //
                //------------------------------------------------------------//

                ClosePrinter(hPrinter);
            }

            if (bSuccess == false)
            {
                //------------------------------------------------------------//
                //                                                            //
                // If write did not succeed, GetLastError may give more       //
                // information about the failure.                             //
                //                                                            //
                //------------------------------------------------------------//

                dwError = Marshal.GetLastWin32Error();
            }

            return(result);
        }
        //--------------------------------------------------------------------//
        //                                                        M e t h o d //
        // s e n d B y t e s T o P r i n t e r                                //
        //--------------------------------------------------------------------//
        //                                                                    //
        // The function is given a printer name and an unmanaged array of     //
        // bytes; the function sends those bytes to the print queue.          //
        // Returns true on success, false on failure.                         //
        //                                                                    //
        //--------------------------------------------------------------------//

        public static bool sendBytesToPrinter(String szPrinterName,
                                              IntPtr pBytes,
                                              Int32 dwCount)
        {
            Int32  dwError = 0, dwWritten = 0;
            IntPtr hPrinter = new IntPtr(0);

            DOCINFOA di = new DOCINFOA();

            Boolean bSuccess = false;

            di.pDocName  = "My C#.NET RAW Document";
            di.pDataType = "RAW";

            //----------------------------------------------------------------//
            //                                                                //
            // Open the printer.                                              //
            //                                                                //
            //----------------------------------------------------------------//

            if (OpenPrinter(szPrinterName.Normalize(), out hPrinter, IntPtr.Zero))
            {
                //------------------------------------------------------------//
                //                                                            //
                // Start a document.                                          //
                //                                                            //
                //------------------------------------------------------------//

                if (StartDocPrinter(hPrinter, 1, di))
                {
                    //--------------------------------------------------------//
                    //                                                        //
                    // Start a page.                                          //
                    //                                                        //
                    //--------------------------------------------------------//

                    if (StartPagePrinter(hPrinter))
                    {
                        //----------------------------------------------------//
                        //                                                    //
                        // Write supplied bytes.                              //
                        //                                                    //
                        //----------------------------------------------------//

                        bSuccess = WritePrinter(hPrinter, pBytes, dwCount,
                                                out dwWritten);

                        //----------------------------------------------------//
                        //                                                    //
                        // End page.                                          //
                        //                                                    //
                        //----------------------------------------------------//

                        EndPagePrinter(hPrinter);
                    }

                    //--------------------------------------------------------//
                    //                                                        //
                    // End document.                                          //
                    //                                                        //
                    //--------------------------------------------------------//

                    EndDocPrinter(hPrinter);
                }

                //------------------------------------------------------------//
                //                                                            //
                // Close the printer.                                         //
                //                                                            //
                //------------------------------------------------------------//

                ClosePrinter(hPrinter);
            }
            if (bSuccess == false)
            {
                //------------------------------------------------------------//
                //                                                            //
                // If write did not succeed, GetLastError may give more       //
                // information about the failure.                             //
                //                                                            //
                //------------------------------------------------------------//

                dwError = Marshal.GetLastWin32Error();
            }

            return(bSuccess);
        }
Example #32
0
        private static void OpenDrawerByPrinter()
        {
            //Settings settings = new Settings();
            //settings.getValuesFromRegistry();
            string PrinterName="";
            IntPtr hPrinter = new IntPtr(0);
            if (OpenPrinter(PrinterName, out hPrinter, 0))
            {
                Int32 dwWritten = 0;

                DOCINFOA docinfo = new DOCINFOA();
                docinfo.pDocName = "CashPop";

                if (StartDocPrinter(hPrinter, 1, docinfo))
                {
                    if (StartPagePrinter(hPrinter))
                    {
                        IntPtr pBytesCommandOpenDrawer = Marshal.UnsafeAddrOfPinnedArrayElement(commandOpenDrawer, 0);
                        WritePrinter(hPrinter, pBytesCommandOpenDrawer, commandOpenDrawer.Length, out dwWritten);
                        Marshal.FreeCoTaskMem(pBytesCommandOpenDrawer);

                        EndPagePrinter(hPrinter);
                    }
                    EndDocPrinter(hPrinter);
                }
                ClosePrinter(hPrinter);
            }
        }