guicopyjob.c

这个是boot gui的程序

/*
 *  Start of Zoran Standard Header
 *  Copyright (c) 2005 Zoran Corporation
 *  
 *  All rights reserved.  Proprietary and confidential.
 *  
 *  DESCRIPTION for guicopyjob.c
 *      GUI copy job action routine
 *  
 *  NEW HISTORY COMMENT (description must be followed by a blank line)
 *  <Enter change description here>

 *  ===== HISTORY of changes in //depot/imgeng/sw/se_gw/gui/guicopyjob.c
 *  
 *  13/Dec/05 #3  dstrauss   Delete obsolete comment.
 *   7/Dec/05 #1  dstrauss   Created.
 *  
 *
 *  End of Zoran Standard Header
 */
#include "standard.h"
#include "propman.h"
#include "job.h"
#include "jobcopy.h"
#include "paper.h"
#include "guiproperties.h"
#include "guiactions.h"

/* Data source/sink name */
#define SRCNAME_SCANNER          "SCANNER"   /* Scanner device name */
#ifdef    PHOTO_PRINT_WITHOUT_PRINT_ENGINE
#  ifdef    HPC
#    define SNKNAME_PRINTER      "RAWSINK"   // raw print to file
#  else  // NOT HPC
#    define SNKNAME_PRINTER      "TESTSINK"  // print to null device
#endif // HPC
#else  // NOT PHOTO_PRINT_WITHOUT_PRINT_ENGINE - i.e. normal print environment
#  define SNKNAME_PRINTER      "PRINTER"   // Printer device name
#endif // PHOTO_PRINT_WITHOUT_PRINT_ENGINE

static Uint8 alignment[8]={5, 5, 5, 5, 5, 5, 5, 5};

/* start a copy job.  If bColor is TRUE, do a color copy; else
 * do monochrome.
 */
static void doCopyJob(int bColor)
{
  JOB*  pCopyJob;
  Uint32 srx, sry;
  int brx, bry;
  int pw, ph;
  int ow, oh;
  e_PaperSize paperSize;
  int quality;
  int imagemode;
  int papertype;
  int scale;
  int printhead;
  int psize;

  pCopyJob = JobNew();

  // set job type
  JobSetJobType(pCopyJob, JOB_COPY);

  if( !JobPermissionToStart(pCopyJob) ) {
    JobDelete(pCopyJob);
    return; // busy
  }

  ASSERT(pCopyJob);
  JobInit(pCopyJob);
  JobInitSource(pCopyJob);
  JobInitSink(pCopyJob);

  // Set source and sink
  JobSetSourceName(pCopyJob, SRCNAME_SCANNER);
  JobSetSinkName(pCopyJob, SNKNAME_PRINTER);

  // Set printhead info
  printhead = 0x30; // Black:0x3x, Photo:0x7x, Color:0x5x

  // Get photo/black head ID
  OMgetInt(omCartridge1ID, OMCURRENT, &printhead);
  // Photo
  if( (printhead & 0x70) == 0x70 ) {
    JobSetPrintHead(pCopyJob, PrintHeadKcm);// photo print head type
  }
  // Black
  else {
    JobSetPrintHead(pCopyJob, PrintHeadCMYK);// mono print head type
  }

  JobSetPages(pCopyJob, 1, 0, 1);

  // Record which button was pushed, black or color
  JobSetButton(pCopyJob, (bColor ? FPButtonColor : FPButtonBlack));

  quality = GPMGetSavedValue(GPID_QUALITY);
  if (quality == GPID_QUALITY_BEST) {
    /* "Best" quality */
    srx = 600;
    sry = 600;
  } else if (quality == GPID_QUALITY_NORMAL) {
    /* "Normal" quality */
    srx = 300;
    sry = 600;
  } else {                      /* assume draft quality */
    /* "Draft" quality */
    srx = 150;
    sry = 150;
  }

  // Get source document size
  GetPaperPhysicalDimensions(PS8p5x11, &brx, &bry);

  // papertable dimensions are based on 1200 dpi, so cut
  brx /= 2;
  bry /= 2;

  ow = brx;
  oh = bry;

  // Get print size

  // Set paper size
  psize = GPMGetSavedValue(GPID_PAPERSIZE);
  if (psize == GPID_PAPERSIZE_LETTER) {
    PSPRINTF("Copy outputpage = Letter\n"); 
    paperSize = PS8p5x11;
  } else {
    PSPRINTF("Copy outputpage = A4\n"); 
    paperSize = PSA4;
  } 
  /* NOTE - add handling for other paper sized here */

  GetPaperPrintableDimensions(paperSize, &pw, &ph);

  // papertable dimensions are based on 1200 dpi, so cut
  pw /= 2;
  ph /= 2;

  ow = ow * srx / 600;
  oh = oh * sry / 600;

  ow = ((ow+31)/32)*32; // round to 32 pixel multiple

  // Set other properties
  JobSetSourceWidth(pCopyJob, ow); // source width
  JobSetSourceLength(pCopyJob, oh); // source height
  JobSetSourceResX(pCopyJob, srx);
  JobSetSourceResY(pCopyJob, sry);

  // Setting the scan area
  JobSetSourceWindowXPos(pCopyJob, 0);
  JobSetSourceWindowYPos(pCopyJob, 0);
  JobSetSourceWindowXExtent(pCopyJob, ow);
  JobSetSourceWindowYExtent(pCopyJob, oh);

  // Set image attributes
  JobSetSourceBitsPerSample(pCopyJob, 16); // 16 bit/pixel

  if( bColor ) {
    JobSetSourceSamplesPerPixel(pCopyJob, 3);	// color
    JobSetSourcePhotometric(pCopyJob, JOB_SOURCE_PHOTOMETRIC__RGB);
  } else {
    if ((quality == GPID_QUALITY_BEST) 
        || (JobGetPrintHead(pCopyJob) == PrintHeadKcm)) {
      JobSetSourceSamplesPerPixel(pCopyJob, 3);	// color input
      JobSetSourcePhotometric(pCopyJob, JOB_SOURCE_PHOTOMETRIC__RGB);
    }
    else {
      JobSetSourceSamplesPerPixel(pCopyJob, 1);	// monochrome
      JobSetSourcePhotometric(pCopyJob, JOB_SOURCE_PHOTOMETRIC__MONO);
    }
  }

  JobSetSourceCompression(pCopyJob, JOB_SOURCE_COMPRESSION__UNCOMPRESSED);
  JobSetSourcePlanarConfig(pCopyJob, JOB_SOURCE_PLANAR_CONFIG__CHUNCKY);
  JobSetSourceNumberOfBytes(pCopyJob, JobCalcSourceNumberOfBytes(pCopyJob));

  // print area
  JobSetSinkWidth(pCopyJob, (pw + 3) & ~ 3);	// sink width (rnd up to dword)
  JobSetSinkLength(pCopyJob, ph);				// sink height

  // print resolution
  JobSetSinkResX(pCopyJob, 600);				// sink hor. res -- dpi
  JobSetSinkResY(pCopyJob, 600);				// sink ver. res -- dpi

  JobSetSinkBitsPerSample(pCopyJob, 1);
  if( bColor ) {
    JobSetSinkSamplesPerPixel(pCopyJob, 4);	// color printing
    JobSetSinkPhotometric(pCopyJob, JOB_SINK_PHOTOMETRIC__CMYK);
  }
  else {
    if( (quality == GPID_QUALITY_BEST)
        || (JobGetPrintHead(pCopyJob) == PrintHeadKcm) ) {
      JobSetSinkSamplesPerPixel(pCopyJob, 4);	// hybrid printing
      JobSetSinkPhotometric(pCopyJob, JOB_SINK_PHOTOMETRIC__CMYK);
      JobSetHybrid(pCopyJob, 1);
    }
    else {
      JobSetSinkSamplesPerPixel(pCopyJob, 1);	// mono printing
      JobSetSinkPhotometric(pCopyJob, JOB_SINK_PHOTOMETRIC__MONO);
      JobSetHybrid(pCopyJob, 0);
    }
  }

  JobSetSinkCompression(pCopyJob, JOB_SINK_COMPRESSION__UNCOMPRESSED);
  JobSetSinkPlanarConfig(pCopyJob, JOB_SINK_PLANAR_CONFIG__CHUNCKY);
  JobSetSinkNumberOfBytes(pCopyJob, JobCalcSinkNumberOfBytes(pCopyJob));

  imagemode = GPMGetSavedValue(GPID_MODE);
  if (imagemode == GPID_MODE_AUTO) {
    JobSetImageMode(pCopyJob, ImageModeAuto);
  } else if (imagemode == GPID_MODE_PHOTO) {
    JobSetImageMode(pCopyJob, ImageModePhoto);
  } else {
    JobSetImageMode(pCopyJob, ImageModeText);
  }

  JobSetFaxMode(pCopyJob, FaxModeNormal);

  if (quality == GPID_QUALITY_DRAFT) {
    JobSetPrintQuality(pCopyJob, PrintQualityDraft);
  } else if (quality == GPID_QUALITY_NORMAL) {
    JobSetPrintQuality(pCopyJob, PrintQualityNormal);
  } else {                      /* assume GPID_QUALITY_BEST */
    JobSetPrintQuality(pCopyJob, PrintQualityBest);
  }

  papertype = GPMGetSavedValue(GPID_PAPERTYPE);
  if (papertype == GPID_PAPERTYPE_PLAIN) {
    JobSetPrintMedia(pCopyJob,  PrintMediaPlain);
  } else {                      /* assume photo paper */
    JobSetPrintMedia(pCopyJob,  PrintMediaPhoto);
  }

  scale = GPMGetSavedValue(GPID_SCALE);
  JobSetHScale(pCopyJob, scale * 10); // set scale factor
  JobSetVScale(pCopyJob, scale * 10); // default scale factor

  PSPRINTF("COPY parameters:\n"
           "     ow %d oh %d\n"
           "     srx %d sry %d\n"
           "     pw %d ph %d\n"
           "     imageQuality %d printhead %d\n"
           "     imageType %d paperType %d scaleValue %d\n",
           ow, oh, srx, sry, pw, ph,
           quality, JobGetPrintHead(pCopyJob),
           imagemode, papertype, scale
           );

  JobSetCopyNo(pCopyJob, GPMGetSavedValue(GPID_COPIES));

  // set shingling mode
  JobSetShingling(pCopyJob, SHINGLING_MODE_2_PASS);

  // set print head alignment value
  JobSetVerticalAlignment(pCopyJob, alignment);

  // set operation mode
  JobSetOPMode(pCopyJob, OpModeNormal);

  if(quality == GPID_QUALITY_DRAFT) { /* draft quality */
    StartTwoPartCopyJob(pCopyJob);
  }  else {
    CopyJobStart(pCopyJob);
  }

  return;
}

void GUIActionCopyJobColor(void)
{
  doCopyJob(TRUE);
}

void GUIActionCopyJobMono(void)
{
  doCopyJob(FALSE);
}