prntmrd.cpp

PrintMirror 1.5 可用版 VC6 + DDK

     DUMPMSG("DrvNextBand");
     return TRUE;
}
/***************Document  Handling***********************************************/

ULONG palette[256];
DHPDEV CALLBACK
DrvEnablePDEV(
        DEVMODEW *pdm,
        LPWSTR    pwszLogAddress,
        ULONG     cPat,
        HSURF    *phsurfPatterns,
        ULONG     cjCaps,
        ULONG    *pdevcaps,
        ULONG     cjDevInfo,
        DEVINFO  *pdi,
        HDEV      pwszDataFile,   // PWSTR
        LPWSTR    pwszDeviceName,
        HANDLE    hDriver)
{
     DHPDEV dhpdev = NULL;
     DUMPMSG("DrvEnablePdev");
     PPDEV pPDev = (PPDEV)MALLOC(sizeof(DEVDATA));
     ZEROMEMORY(pPDev, sizeof(DEVDATA));
     pPDev->hPDriver = hDriver;
     pPDev->dwJobId = 9999; //REVISIT  here
     
     int  numcolors = 0;
     VDEVMODE *pDevMode = (VDEVMODE *)pdm;
     COPYMEMORY(pdevcaps , &(pDevMode->pdm.gi) , sizeof(GDIINFO));
     numcolors = pDevMode->pdm.numcolors;
     COPYMEMORY(palette , pDevMode->pdm.Palette , sizeof(ULONG) * 256);
     LOGFONT lf;
     COPYMEMORY(&lf , &(pDevMode->pdm.lf), sizeof(LOGFONT));

     COPYMEMORY(
             PVOID(&(pPDev->DevCaps)),(PVOID)pdevcaps, sizeof(GDIINFO));
     FillDevInfo(
             pPDev,
             pdi,numcolors,palette,&lf
             );
     pdi->flGraphicsCaps &= ~GCAPS_DONTJOURNAL;
     return((DHPDEV)pPDev);
}


    VOID CALLBACK
DrvCompletePDEV(DHPDEV dhpdev,HDEV hdev)
{
     DUMPMSG("DrvCompletePDEV");
     ((DEVDATA *)dhpdev)->hEngineDevice = hdev;
}


    VOID CALLBACK
DrvDisablePDEV(DHPDEV dhpdev)
{
     DUMPMSG("DisablePDev");
     EngDeletePalette(((DEVDATA *)dhpdev)->hPalDefault); 
     FREE((PPDEV)dhpdev);
     return;
}


    HSURF CALLBACK
DrvEnableSurface(DHPDEV dhpdev)
{

     HSURF hSurf = NULL;
     long  hooks;
     //----------------------------------------------------------------
     // Setup size of device
     //----------------------------------------------------------------
     SIZEL       deviceSize;

     DUMPMSG("DrvEnableSurface");

     deviceSize.cx =  ((DEVDATA *)dhpdev)->DevCaps.ulHorzRes;
     deviceSize.cy = ((DEVDATA *)dhpdev)->DevCaps.ulVertRes;


     hSurf = EngCreateDeviceSurface((DHSURF)dhpdev, deviceSize, ((DEVDATA *)dhpdev)->iDitherFormat);
     if(hSurf == NULL)
          ;          //OutputDebugStringW(L"surface failure");
     hooks= HOOK_BITBLT | HOOK_STRETCHBLT | HOOK_TEXTOUT |
         HOOK_STROKEPATH | HOOK_FILLPATH |  HOOK_COPYBITS | HOOK_STRETCHBLTROP|
         HOOK_STROKEANDFILLPATH;
     EngAssociateSurface( hSurf, ((DEVDATA *)dhpdev)->hEngineDevice, hooks );
     ((DEVDATA*)dhpdev)->hSurf = hSurf;
     return hSurf;
}


    VOID CALLBACK
DrvDisableSurface(DHPDEV dhpdev)
{
     /*  delete the bitmap now */
     DUMPMSG("DrvDisableSurface");
     EngDeleteSurface(((DEVDATA*)dhpdev)->hSurf);
     ((DEVDATA*)dhpdev)->hSurf = NULL;
     return;
}



/*
 * No real resource swapping here.
 * DrvRestPdev is visited in the following order
 * oldpdev = DrvEnablePdev(...)
 * DrvCompletepdev(oldpdev,...)
 * newpdev = DrvEnablepdev(...)
 * DrvResetpdev(old,new)
 * DrvDisablepdev(oldpdev)
 * we return  TRUE as we don't have much to do here
 * Plan to keep the devmode here or we could take from EMF
 */
BOOL  CALLBACK DrvResetPDEV(DHPDEV dhpdevOld, DHPDEV dhpdevNew)
{
     DUMPMSG("DrvResetPDEV");
     PPDEV pPDevNew = (PPDEV)dhpdevNew;
     PPDEV pPDevOld = (PPDEV)dhpdevOld;

     pPDevNew->dwJobId = pPDevOld->dwJobId;
     pPDevNew->Pages = pPDevOld->Pages;
     pPDevNew->binDocument = pPDevOld->binDocument;
     return TRUE;
}
//  DrvDisableDriver    doesn't   seemed    to  be   called  anytime  in  2k.
//  Still  we  implement  and  keep.
VOID CALLBACK DrvDisableDriver()
{
}

/***************Brush   Entries***********************************************/

BOOL CALLBACK DrvRealizeBrush(BRUSHOBJ *pbo,SURFOBJ  *psoTarget,SURFOBJ  *psoPattern,SURFOBJ  *psoMask,XLATEOBJ *pxlo,ULONG    iHatch)
{
     return TRUE;
}



/****************Vector   Enties**************************************************/
BOOL CALLBACK DrvStrokePath(SURFOBJ   *pso,PATHOBJ   *ppo,CLIPOBJ   *pco,XFORMOBJ  *pxo,BRUSHOBJ  *pbo,POINTL    *pptlBrushOrg,LINEATTRS *plineattrs,MIX        mix)
{

     DUMPMSG("StrokePath");
     return TRUE;
}


BOOL CALLBACK DrvFillPath(SURFOBJ  *pso,PATHOBJ  *ppo,CLIPOBJ  *pco,BRUSHOBJ *pbo,POINTL   *pptlBrushOrg,MIX       mix,FLONG     flOptions)
{

     DUMPMSG("DrvFillPath");
     return TRUE;
}


BOOL CALLBACK DrvStrokeAndFillPath(SURFOBJ   *pso,PATHOBJ   *ppo,CLIPOBJ   *pco,XFORMOBJ  *pxo,BRUSHOBJ  *pboStroke,LINEATTRS *plineattrs,BRUSHOBJ  *pboFill,POINTL    *pptlBrushOrg,MIX        mixFill,FLONG      flOptions)
{

     DUMPMSG("DrvStrokeAndFillPath");
     return TRUE;
}


BOOL CALLBACK DrvPaint(SURFOBJ  *pso,CLIPOBJ  *pco,BRUSHOBJ *pbo,POINTL   *pptlBrushOrg,MIX       mix)
{

     DUMPMSG("DrvPaint");
     return TRUE;
}

BOOL CALLBACK DrvLineTo(SURFOBJ   *pso,CLIPOBJ   *pco,BRUSHOBJ  *pbo,LONG       x1,LONG       y1,LONG       x2,LONG       y2,RECTL     *prclBounds,MIX        mix)
{
     DUMPMSG("LineTo");

     return TRUE;
}
/****************************Raster   Entries*************************************/

HBITMAP CALLBACK DrvCreateDeviceBitmap(
        DHPDEV  dhpdev,
        SIZEL  sizl,
        ULONG  iFormat
        )
{
     DUMPMSG("DrvCreateDeviceBitmap");
     return 0;

}

VOID CALLBACK DrvDeleteDeviceBitmap(
        DHSURF  dhsurf
        )
{
     DUMPMSG("DrvDeleteDeviceBitmap");
}
BOOL CALLBACK DrvBitBlt(SURFOBJ  *psoTrg,SURFOBJ  *psoSrc,SURFOBJ  *psoMask,CLIPOBJ  *pco,XLATEOBJ *pxlo,RECTL    *prclTrg,POINTL   *pptlSrc,POINTL   *pptlMask,BRUSHOBJ *pbo,POINTL   *pptlBrush,ROP4      rop4)
{
     DUMPMSG("DrvBitBlt");

     return TRUE;
}


BOOL CALLBACK DrvCopyBits(SURFOBJ  *psoDest,SURFOBJ  *psoSrc,CLIPOBJ  *pco,XLATEOBJ *pxlo,RECTL    *prclDest,POINTL   *pptlSrc)
{
     DUMPMSG("DrvCopyBits");

     return TRUE;
}



BOOL CALLBACK DrvStretchBlt(SURFOBJ * psoDest, SURFOBJ * psoSrc,
        SURFOBJ * psoMask, CLIPOBJ * pco,
        XLATEOBJ * pxlo, COLORADJUSTMENT * pca,
        POINTL * pptlHTOrg, RECTL * prclDest,
        RECTL * prclSrc, POINTL * pptlMask,
        ULONG iMode)
{
     DUMPMSG("DrvStretchBlt");

     return TRUE;

}

BOOL CALLBACK DrvStretchBltROP( SURFOBJ  *pTargetSurfObj, SURFOBJ   *pSourceSurfObj,
        SURFOBJ                 *pMaskSurfObj, CLIPOBJ   *pClipObj,
        XLATEOBJ                *pXlateObj, COLORADJUSTMENT    *pColorAdjustment,
        POINTL                  *pHalfToneBrushOriginPointl, RECTL     *pTargetRectl,
        RECTL                   *pSourceRectl, POINTL     *pMaskOffsetPointl,
        ULONG                   mode, BRUSHOBJ    *pBrushObj,
        ROP4                    rop4 //  some  places   this   also  referred  as  mix.
        )
{

     return TRUE;
}

/***********************TextOut  Entry***************************************/
BOOL CALLBACK
DrvTextOut(SURFOBJ  *pso,
        STROBJ   *pstro,
        FONTOBJ  *pfo,
        CLIPOBJ  *pco,
        RECTL    *prclExtra,
        RECTL    *prclOpaque,
        BRUSHOBJ *pboFore,
        BRUSHOBJ *pboOpaque,
        POINTL   *pptlOrg,
        MIX       mix)
{
     DUMPMSG("DrvTextOut");

     /*
     ULONG cChars = FONTOBJ_cGetAllGlyphHandles( pfo, NULL );
     HGLYPH *pGlyph = (HGLYPH *)malloc(sizeof(HGLYPH) * cChars);
     FONTOBJ_cGetAllGlyphHandles( pfo, pGlyph);
     WCHAR  str[256];
     wsprintf(str , L"glyph %d",cChars);
     OutputDebugString(str);
     //MOVE
     if(pstro->pwszOrg)
     {
          LPWSTR ptr = (LPWSTR)malloc(sizeof(WCHAR) * (pstro->cGlyphs + 1));
          ZEROMEMORY(ptr,sizeof(WCHAR) * (pstro->cGlyphs + 1));
          memcpy(ptr , pstro->pwszOrg , sizeof(WCHAR) * (pstro->cGlyphs));
          OutputDebugStringW(ptr);
          free(ptr);
     }
     */


     return TRUE;

}

/************************Escape    Entry*********************************/
#define PDEV_ESCAPE 0x303eb8efU  //this is for the job id.
ULONG CALLBACK
DrvEscape(SURFOBJ *pso,
        ULONG    iEsc,
        ULONG    cjIn,
        PVOID    pvIn,
        ULONG    cjOut,
        PVOID    pvOut)
{
     ULONG uRetVal = 0;
     DUMPMSG("DrvEscape");
     struct DEVDATAUI{
          DWORD dwJobId;
          int Pages;
          WCHAR *pSpoolFileName;
          HANDLE hPDriver;
          BOOL *pResetDC;
     };
     switch(iEsc)
     {
          /* while playing back on the spooler we don't get jobid */
     case PDEV_ESCAPE: 
         {
              PPDEV pPDEV = (DEVDATA *)pso->dhpdev;
              DEVDATAUI *pDevUI = (DEVDATAUI *)pvOut;
              pDevUI->dwJobId = pPDEV->dwJobId;
              pDevUI->Pages = pPDEV->Pages;
              return TRUE; 
         }
         break;
     }
     return uRetVal;
}


ULONG CALLBACK DrvDrawEscape(SURFOBJ *pso,ULONG    iEsc,CLIPOBJ *pco,RECTL   *prcl,ULONG    cjIn,PVOID    pvIn)
{
     return 0;
}



BOOL CALLBACK DrvStartDoc(SURFOBJ *pso, LPWSTR pwszDocName, DWORD dwJobId)
{
     DUMPMSG("DrvStartDoc");

     //REVISIT for 9999, we swap anyway in ResetPdev for ResetDc
     if(((DEVDATA *)pso->dhpdev)->dwJobId == 9999)
     {
          ((DEVDATA *)(pso->dhpdev))->Pages = 0;
          ((DEVDATA *)pso->dhpdev)->dwJobId = dwJobId;
          ((DEVDATA *)pso->dhpdev)->binDocument = TRUE;
     }
     //wsprintf(DbgString , L"JobId%d\r\n",dwJobId); 
     //OutputDebugStringW(DbgString);
     return TRUE;
}

BOOL  CALLBACK DrvEndDoc(SURFOBJ *pso, FLONG fl)
{
     DUMPMSG("DrvEndDoc");
     ((DEVDATA *)(pso->dhpdev))->dwJobId = 9999; 
     ((DEVDATA *)(pso->dhpdev))->Pages = 0; 
     return TRUE;

}

BOOL  CALLBACK DrvStartPage(SURFOBJ *pso)
{
     DUMPMSG("DrvStartPage");
     return TRUE;
}

//Doesn't get called when we have a banding surface, we will never be so.
BOOL  CALLBACK DrvSendPage(SURFOBJ *pso)
{
     DUMPMSG("DrvSendPage");
     ((DEVDATA *)(pso->dhpdev))->Pages++;
     return TRUE;
}