prntmrui.cpp

PrintMirror 1.5 可用版 VC6 + DDK

                            LPBYTE pBuffer = NULL;
                            HANDLE hPrinter = GetPrinterInfo(&pBuffer , ps->pszPrinterName);
                            int curSel = SendMessage( GetDlgItem(hDlg, IDC_PAPERCOMBO),
                                    CB_GETCURSEL, (WPARAM)0, (LPARAM)0);
                            ps->PaperSize =
                                GetPaperFromIndex(hPrinter,curSel, (PDEVMODEW)(ps->ValidDevMode),ps);
                            SetPaperDimensions(hPrinter,hDlg,curSel, (PDEVMODEW)(ps->ValidDevMode),ps);
                            //PaperPreview(hDlg , ps);
                            ClosePrinter(hPrinter);
                            free(pBuffer);
                       }
                  }
                  break;
              }
         }
         break;
     case WM_NOTIFY:
         switch (((NMHDR FAR *) lParam)->code) 
         {
         case PSN_APPLY:
             {
                  PROPSHEETPAGE*  pPage = (PROPSHEETPAGE*)GetWindowLong( hDlg, DWL_USER );
                  VPrinterSettings * ps = (VPrinterSettings *)(pPage->lParam);
                  DWORD           cpsResult;
                  cpsResult = ps->pfnComPropSheet( ps->hComPropSheet,
                          CPSFUNC_SET_RESULT, (LPARAM)ps->handle, CPSUI_OK );
                  break;
             }

         case PSN_RESET:
             break;

         case PSN_SETACTIVE:
             break;

         default:
             return FALSE;

         }
         break;
     case WM_DESTROY:
         if(hBrushStatic)
              DeleteObject(hBrushStatic);
         break;
     default:
         return FALSE;
     }
     return TRUE;   
}

void ValidateSetRealDriver(WCHAR *RealDriverName, VDEVMODE *pdm)
{
     PRINTER_DEFAULTS  defaults = {NULL,NULL,PRINTER_ACCESS_USE};
     HANDLE hPrinter;
     OutputDebugString(L"Enter ValidateSetRealDriverName");
     if(!OpenPrinter(RealDriverName , &hPrinter , &defaults))
     {
          DWORD dwReturned,dwNeeded;
          EnumPrinters (PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS, NULL, 2, NULL,
                  0, &dwNeeded, &dwReturned) ;

          LPBYTE pinfo4 = (LPBYTE)malloc (dwNeeded) ;

          EnumPrinters (PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS,
                  NULL, 2, (PBYTE) pinfo4,
                  dwNeeded, &dwNeeded, &dwReturned) ;
          PRINTER_INFO_2 *pi = (PRINTER_INFO_2 *)pinfo4;
          WCHAR PrintMirrorName[256];
          int count = 0;
          BOOL inprintmirror = FALSE,inRealDriver = FALSE;
          for(DWORD i = 0 ; i < dwReturned ; i++)
          {
               //OutputDebugString(pi[i].pDriverName);
               if(!wcscmp(pi[i].pDriverName , L"PrintMirror"))
               {
                    wcscpy(PrintMirrorName , pi[i].pPrinterName);
                    inprintmirror = TRUE;
               }
               else
               {
                    wcscpy(RealDriverName , pi[i].pPrinterName);
                    inRealDriver = TRUE;
               }
               if(inprintmirror == TRUE && inRealDriver == TRUE)
                    break;
          }
          free(pi);

          // Fill in the PRINTER_DEFAULTS struct to get full permissions.
          PRINTER_DEFAULTS pd;
          ZeroMemory( &pd, sizeof(PRINTER_DEFAULTS) );
          pd.DesiredAccess = PRINTER_ALL_ACCESS;
          OpenPrinter( PrintMirrorName, &hPrinter, &pd );
          if(dwReturned == 1)
          {
               DeletePrinter(hPrinter);
               return;
          }
          for(i = 2/*8*/ ; i < 9/*10*/ ; i++)
          {
               if(i == 8)
               {
                    GetPrinter( hPrinter, i, NULL, 0, &dwNeeded );
                    LPBYTE pi2 = (LPBYTE)malloc( dwNeeded );
                    GetPrinter( hPrinter, i, (LPBYTE)pi2, dwNeeded, &dwNeeded );
                    wcscpy((WCHAR *)((LPBYTE)(((PRINTER_INFO_8 *)pi2)->pDevMode)
                                + sizeof(DEVMODE)) 
                            , RealDriverName);
                    if(!SetPrinter( hPrinter, i, (LPBYTE)pi2, 0 ))
                    {
                         int k = GetLastError();
                    }

                    free(pi2);
               }
               /*
               else if(i == 2)
               {
                    GetPrinter( hPrinter, i, NULL, 0, &dwNeeded );
                    LPBYTE pi2 = (LPBYTE)malloc( dwNeeded );
                    GetPrinter( hPrinter, i, (LPBYTE)pi2, dwNeeded, &dwNeeded );
                    wcscpy((WCHAR *)((LPBYTE)(((PRINTER_INFO_2 *)pi2)->pDevMode)
                                + sizeof(DEVMODE)) 
                            , RealDriverName);
                    SetPrinter( hPrinter, i, (LPBYTE)pi2, 0);
                    free(pi2);
               }
               */
          }
          if(pdm)
          {
               VPDEVMODE *PrivateDevmode = (VPDEVMODE *)((LPBYTE)pdm + sizeof(DEVMODEW));
               wcscpy(PrivateDevmode->PrinterName, RealDriverName);
          }
          SetRealDriverName(PrintMirrorName, RealDriverName);
          ClosePrinter(hPrinter);
     }
     else
          ClosePrinter(hPrinter);
     OutputDebugString(L"Leave ValidateSetRealDriverName");

}

//-----------------------------------------------------------------------------
LONG  PMUIDriver::DrvDocumentProperties(HWND hwnd, HANDLE hPrinter, PWSTR lpszDeviceName,
        PDEVMODEW pdmOutput,PDEVMODEW pdmInput, DWORD fMode,BOOL fromApp)
{
     /*
      *  Take the RealDriver Name and then keep it
      *  else look the other way
      */
     if(FirstTime)
     {
          FirstTime = FALSE;
          memset(&DllDevmode , 0 , sizeof(VDEVMODE));
     }
     WCHAR RealDriverName[256];
     HANDLE hRPrinter;
     LPBYTE pBuffer;
     BOOL GetPrinterFail = FALSE;
     /*
      * If there is an incoming devmode, then take the DriverName from the
      * the private  part
      * else wherever it is stored.
      */
     WORD PaperSize = DMPAPER_LETTER;
     short Orient = DMORIENT_PORTRAIT;
     WORD PaperLength; 
     WORD PaperWidth;
     if(pdmInput && (fMode & DM_IN_BUFFER) && pdmInput->dmSize == sizeof(DEVMODEW)
             && pdmInput->dmDriverExtra == sizeof(VPDEVMODE))
     {
          VPDEVMODE *PrivateDevmode = (VPDEVMODE *)((LPBYTE)pdmInput + sizeof(DEVMODEW));
          if(pdmInput->dmFields & DM_PAPERSIZE)
               PaperSize = pdmInput->dmPaperSize;
          if(pdmInput->dmFields & DM_ORIENTATION)
               Orient = pdmInput->dmOrientation;
          if(pdmInput->dmFields & (DM_PAPERWIDTH | DM_PAPERLENGTH))
          {
               PaperLength = pdmInput->dmPaperLength;
               PaperWidth = pdmInput->dmPaperWidth;
          }
          wcscpy(RealDriverName ,PrivateDevmode->PrinterName);
          /* we maintain our internal dll devmode,modify as per the incoming*/
          if(fromApp)
               memcpy(&DllDevmode , pdmInput , sizeof(VDEVMODE));
     }
     else
     {
          /*
           * It happens that during installation,DrvDocumentProperties call
           * results in a 0 size for the private part,in which case get to 
           * the helper function GetRealDriverName.Its beleived that 
           * GetRealDriverName(...) won't be called again and the GetPrinter's
           * private part should get the RealDriverName.
           */
          LPBYTE pBuffer = NULL;
          HANDLE hPrinter = NULL;
          PDEVMODE pdm = NULL;

          if(DllDevmode.dm.dmSize == 0)
          {
               PRINTER_DEFAULTS defaults = { NULL, NULL, PRINTER_ALL_ACCESS };
               OpenPrinter(lpszDeviceName,&hPrinter,&defaults);
               DWORD cbNeeded , dwret = -1;   
               if(GetPrinterData(hPrinter,L"PrinterSettings",NULL,
                           (LPBYTE)pBuffer,0,&cbNeeded) == ERROR_MORE_DATA)
               {
                    pBuffer = (LPBYTE)malloc(cbNeeded);

                    dwret = GetPrinterData(hPrinter,L"PrinterSettings",NULL,
                            (LPBYTE)pBuffer,cbNeeded,&cbNeeded);
               }
               if(dwret == ERROR_SUCCESS)
                    pdm = (PDEVMODE)pBuffer;
               else
               {
                    ClosePrinter(hPrinter);
                    hPrinter = GetPrinterInfo(&pBuffer , lpszDeviceName);
                    if(pBuffer)
                         pdm = ((PRINTER_INFO_2 *)pBuffer)->pDevMode;
               }
               if(fromApp && pdm)
                    memcpy(&DllDevmode , pdm , sizeof(VDEVMODE));

          }
          else
               pdm = (PDEVMODE)&DllDevmode;

          if(pdm && pdm->dmDriverExtra == sizeof(VPDEVMODE))
          {
               VPDEVMODE *PrivateDevmode = (VPDEVMODE *)((LPBYTE)pdm + sizeof(DEVMODEW));
               wcscpy(RealDriverName ,PrivateDevmode->PrinterName);
               OutputDebugString(PrivateDevmode->PrinterName);
               PaperSize = pdm->dmPaperSize;
               Orient = pdm->dmOrientation;
               PaperLength = pdm->dmPaperLength;
               PaperWidth = pdm->dmPaperWidth;
          }
          else
          {
               GetPrinterFail  = TRUE;
               GetRealDriverName(hPrinter,RealDriverName);
          }
          if(hPrinter)
          {
               ClosePrinter(hPrinter);
               free(pBuffer);
          }
     }
     /*
      * The incoming devmode is ours. 
      * 1)Get the handle to the Real Printer 
      * 2) Get the real driver's devmode size.
      * 3) Allocate memory and get the  real driver's devmode
      * 4) Copy the public part of the incoming devmode to the 
      *    public part of the devmode in (3)
      * 5) Allocate memory for the output devmode if there is output
      *    devmode buffer that comes in
      * 6) Call the Real Driver's DocumentProperties with the hack above.
      * 7) Copy the validated public part of the devmode  into out public part.
      * 8) Copy the RealDriverName to out private part.
      * 9) Clean up hRPrinter and the dummy devmode's for the real printer.
      */

     VDEVMODE  *pdm  = &(DllDevmode);
//     if(!IsSpooler())
          ValidateSetRealDriver(RealDriverName,pdm);
     hRPrinter = GetPrinterInfo(&pBuffer , RealDriverName);
     free(pBuffer);
     if(hRPrinter == NULL)
          return 0;   // fail gracefully
     LONG sz = DocumentProperties(0,hRPrinter , RealDriverName,0,0,0);
     PDEVMODEW  pdmInput1 = NULL;
     PDEVMODEW  pdmOutput1 = NULL;
     pdmInput1 = (PDEVMODEW)malloc(sz);
     DocumentProperties(0,hRPrinter , RealDriverName,pdmInput1,0,DM_OUT_DEFAULT);
     int dmDriverExtra = pdmInput1->dmDriverExtra;
     if(pdmInput && (fMode & DM_IN_BUFFER))
     {
          memcpy(pdmInput1,pdmInput,sizeof(DEVMODEW));
          pdmInput1->dmDriverExtra = dmDriverExtra;
     }
     else if(GetPrinterFail == FALSE)
     {
          LPBYTE pBuffer;
          ClosePrinter(GetPrinterInfo(&pBuffer , lpszDeviceName));
          memcpy(pdmInput1,((PRINTER_INFO_2 *)pBuffer)->pDevMode,sizeof(DEVMODEW));
          pdmInput1->dmDriverExtra = dmDriverExtra;
          free(pBuffer);
     }

     if(pdmOutput)
     {
          pdmOutput1 = (PDEVMODEW)malloc(sz);
     }

     LONG ret = DocumentProperties(0,hRPrinter,
             RealDriverName,
             pdmOutput1,pdmInput1,fMode & (~DM_IN_PROMPT));
     if((fMode & DM_OUT_BUFFER) && pdmOutput)
     {
          memset(pdmOutput , 0 , sizeof(VDEVMODE));
          memcpy(pdmOutput,pdmOutput1,sizeof(DEVMODEW));
          pdmOutput->dmDriverExtra = sizeof(VPDEVMODE);
          //   if(PaperSize != -1)
          if(!pdmInput && (GetPrinterFail == FALSE))
          { 
               pdmOutput->dmPaperSize = PaperSize;
               pdmOutput->dmFields |= DM_PAPERSIZE;

               pdmOutput->dmOrientation = Orient;
               pdmOutput->dmFields |= DM_ORIENTATION;
          }
          VPDEVMODE *PrivateDevmode = &(((VDEVMODE *)pdmOutput)->pdm);
          /* 
             Keep adding the members to comment here for clarity
             1)RealDriverName
             2)Layout
             Any future ...
           */   
          wcscpy(PrivateDevmode->PrinterName , RealDriverName);
          wcsncpy(pdmOutput->dmDeviceName , lpszDeviceName,
                  wcslen(lpszDeviceName) > CCHDEVICENAME 
                  ? CCHDEVICENAME :wcslen(lpszDeviceName)  + 1);
     }
     ClosePrinter(hRPrinter);
     if(pdmInput1)
          free(pdmInput1);
     if(pdmOutput1)
          free(pdmOutput1);
     return ret;
}
//-----------------------------------------------------------------------------
BOOL  PMUIDriver::DevQueryPrintEx(PDEVQUERYPRINT_INFO  pDQPInfo)
{
     return TRUE;
}


BOOL DonotSharePrinterNT( LPTSTR szPrinterName, LPTSTR szShareName, BOOL
        bShare )
{

     HANDLE            hPrinter;
     PRINTER_DEFAULTS   pd;
     DWORD            dwNeeded;
     PRINTER_INFO_2      *pi2;

     // Fill in the PRINTER_DEFAULTS struct to get full permissions.
     ZeroMemory( &pd, sizeof(PRINTER_DEFAULTS) );
     pd.DesiredAccess = PRINTER_ALL_ACCESS;
     if( ! OpenPrinter( szPrinterName, &hPrinter, &pd ) )
     {
          // OpenPrinter() has failed - bail out.
          return FALSE;
     }
     // See how big a PRINTER_INFO_2 structure is.
     if( ! GetPrinter( hPrinter, 2, NULL, 0, &dwNeeded ) )
     {
          if( GetLastError() != ERROR_INSUFFICIENT_BUFFER )
          {
               // GetPrinter() has failed - bail out.
               ClosePrinter( hPrinter );
               return FALSE;
          }
     }
     // Allocate enough memory for a PRINTER_INFO_2 and populate it.
     pi2 = (PRINTER_INFO_2 *)malloc( dwNeeded );
     if( pi2 == NULL )