PrintComponent Class Reference

Provide a component that contains a ptr to the document's PrintControl object. More...

#include <princomp.h>

Inheritance diagram for PrintComponent:

DocComponent ListItem CCObject SimpleCCObject List of all members.

Public Member Functions

 PrintComponent ()
 Construct a print component. DO NOT use this constructor. It gives and ERROR3 (and sets up this in a semi-safe default state).
 PrintComponent (PrintControl *)
 Construct a print component using the given print control object.
 ~PrintComponent ()
 Clean up a print component's data structures - deletes the print control object.
PrintControl * GetPrintControl ()
virtual BOOL WriteEPSComments (EPSFilter *)
 Writes out the print control object in the form of EPS comments in the 'header' comments of the EPS file.
virtual ProcessEPSResult ProcessEPSComment (EPSFilter *, const char *)
 Process an EPS comment - if this is a print component comment, this component will claim it and try to decode it.
virtual BOOL EndExport (BaseCamelotFilter *pFilter, BOOL Success)
 Inform the colour list document component that a Web or Native export has just finished.
BOOL ExportPrintSettings (BaseCamelotFilter *pFilter)
 Export a TAG_PRINTERSETTINGS native file record.
BOOL ExportImagesetting (BaseCamelotFilter *pFilter)
 Export a TAG_IMAGESETTING native file record.
BOOL ExportColourPlate (BaseCamelotFilter *pFilter, ColourPlate *pPlate)
 Export a TAG_COLOURPLATE native file record.
void ImportPrintSettings (CXaraFileRecord *Rec)
 Load a TAG_PRINTERSETTINGS native file record.
void ImportImagesetting (CXaraFileRecord *Rec)
 Load a TAG_IMAGESETTING native file record.
void ImportColourPlate (CXaraFileRecord *Rec, CamelotRecordHandler *pHandler)
 Load a TAG_COLOURPLATE native file record.

Private Member Functions

BOOL OutputValue (UINT32 Token, INT32 Value)
 Outputs a print component token with the given value.
BOOL OutputValue (UINT32 Token, FIXED16 Value)
PCToken GetToken (const char *pComment)
 Outputs a print component token with the given value.
INT32 GetTokenValINT32 (const char *pComment)
 This gets the value after the token part of the comment and returns it as a INT32.
FIXED16 GetTokenValFIXED16 (const char *pComment)
 This gets the value after the token part of the comment and returns it as a FIXED16.
void ExtractTokenValStr (const char *pComment)
 The string representation of the token value is stored in Buffer. If no value is found, or the buffer overflows, Buffer will contain an empty string.

Private Attributes

PrintControl * pPrCtrl
EPSExportDC * pExportDC
TCHAR Buffer [32]

Detailed Description

Provide a component that contains a ptr to the document's PrintControl object.

Author:
Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
Date:
31/3/95
See also:
DocComponent

Definition at line 177 of file princomp.h.


Constructor & Destructor Documentation

PrintComponent::PrintComponent (   ) 
 

Construct a print component. DO NOT use this constructor. It gives and ERROR3 (and sets up this in a semi-safe default state).

Author:
Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
Date:
31/3/95
See also:
PrintComponent

Definition at line 224 of file princomp.cpp.

00225 {
00226     ERROR3("PrintComponent constructed with default constructor!?\n");
00227     pPrCtrl     = NULL;
00228     pExportDC   = NULL;
00229 }

PrintComponent::PrintComponent (  PrintControl *  pThisPrCtrl  ) 
 

Construct a print component using the given print control object.

Author:
Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
Date:
31/3/95
Parameters:
pThisPrCtrl - the print control to use for this print componet. [INPUTS]
Returns:
Errors: ENSURE if pPrCtrl is NULL.
See also:
PrintComponent

Definition at line 246 of file princomp.cpp.

00247 {
00248     ERROR3IF(pThisPrCtrl == NULL, "NULL print control object in print component constructor!");
00249 
00250     // Install this Bitmap list.
00251     pPrCtrl     = pThisPrCtrl;
00252     pExportDC   = NULL;
00253 }

PrintComponent::~PrintComponent (   ) 
 

Clean up a print component's data structures - deletes the print control object.

Author:
Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
Date:
31/3/95
Returns:
Errors: -
See also:
PrintComponent

Definition at line 267 of file princomp.cpp.

00268 {
00269     // Delete our print control object
00270     if (pPrCtrl != NULL)
00271     {
00272         delete pPrCtrl;
00273         pPrCtrl = NULL;
00274     }
00275 }


Member Function Documentation

BOOL PrintComponent::EndExport (  BaseCamelotFilter *  pFilter,
BOOL  Success
)  [virtual]
 

Inform the colour list document component that a Web or Native export has just finished.

Author:
Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
Date:
14/8/96
Parameters:
pFilter - the BaseCamelotFilter filter that is being used to export a file. [INPUTS] Success - True if everything went swimmingly, False if just a clean up is required.
Returns:
TRUE if the component was able to end the importing; FALSE if not (e.g. out of memory)
See also:
DocComponent

Reimplemented from DocComponent.

Definition at line 674 of file princomp.cpp.

00675 {
00676     BOOL ok = TRUE;
00677 
00678     PORTNOTETRACE("print","PrintComponent::EndExport - do nothing");
00679 // WEBSTER - markn 14/2/97
00680 // No print records needed in Webster
00681 #ifndef WEBSTER
00682 #if !defined(EXCLUDE_FROM_RALPH)
00683     if (pFilter == NULL)
00684     {
00685         ERROR3("PrintComponent::EndExport filter is null!");
00686         return(ok);
00687     }
00688 
00689     // If we're not exporting native data, or if export has failed, we do nothing here
00690     if (pFilter->IsWebFilter() || !Success)
00691         return(ok);
00692 
00693     // Export our 3 record types (1 print info, 1 imagesetting info, 'n' colour plates)
00694     ExportPrintSettings(pFilter);
00695     ExportImagesetting(pFilter);
00696 
00697     TypesetInfo *TInfo = TypesetInfo::FindTypesetInfoForDoc(pFilter->GetDocument());
00698     if (TInfo != NULL && TInfo->GetNumPlates() > 0)
00699     {
00700         ColourPlate *pPlate = TInfo->GetFirstPlate();
00701         while (pPlate != NULL)
00702         {
00703             ExportColourPlate(pFilter, pPlate);
00704             pPlate = TInfo->GetNextPlate(pPlate);
00705         }   
00706     }
00707 
00708 #endif // WEBSTER
00709 #endif
00710     return(ok);
00711 }

BOOL PrintComponent::ExportColourPlate (  BaseCamelotFilter *  pFilter,
ColourPlate *  pPlate
) 
 

Export a TAG_COLOURPLATE native file record.

Author:
Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
Date:
14/8/96
Parameters:
pFilter - the BaseCamelotFilter filter that is being used to export a file. [INPUTS] pPlate - the plate to be exported
Returns:
TRUE for success
See also:
PrintingRecordHandler

Definition at line 952 of file princomp.cpp.

00953 {
00954     ERROR3IF(pPlate == NULL, "Illegal NULL params");
00955 
00956     BOOL ok = TRUE;
00957 #if !defined(EXCLUDE_FROM_RALPH)
00958 
00959     // --- Save any referenced spot colour
00960     IndexedColour *pCol = pPlate->GetSpotColour();
00961     INT32 SpotRecordNumber = 0;
00962     if (pCol != NULL)
00963     {
00964         DocColour Fred;
00965         Fred.MakeRefToIndexedColour(pCol);
00966         SpotRecordNumber = pFilter->WriteRecord(&Fred);
00967         ok = (SpotRecordNumber > 0);
00968     }
00969 
00970     // -- Now save the ColourPlate
00971     CXaraFileRecord Rec(TAG_COLOURPLATE, TAG_COLOURPLATE_SIZE);
00972     if (ok)  ok = Rec.Init();
00973 
00974     BYTE Type = 0;
00975     switch(pPlate->GetType())
00976     {
00977         case COLOURPLATE_CYAN:      Type = 1; break;
00978         case COLOURPLATE_MAGENTA:   Type = 2; break;
00979         case COLOURPLATE_YELLOW:    Type = 3; break;
00980         case COLOURPLATE_KEY:       Type = 4; break;
00981         case COLOURPLATE_SPOT:      Type = 5; break;
00982         default:
00983             break;
00984     }
00985                                                                     //  Size    Total
00986     if (ok)  ok = Rec.WriteBYTE(Type);                              //  1       1
00987     if (ok)  ok = Rec.WriteReference(SpotRecordNumber);             //  4       5
00988 
00989     double temp = pPlate->GetScreenAngle();
00990     if (ok)  ok = Rec.WriteDOUBLE(temp);                            //  8       13
00991     temp = pPlate->GetScreenFrequency();
00992     if (ok)  ok = Rec.WriteDOUBLE(temp);                            //  8       21
00993                                                                     //
00994     BYTE Flags = 0x00;                                              //  1       22
00995     if (!pPlate->IsDisabled())      Flags |= 0x01;
00996     if (pPlate->Overprints())       Flags |= 0x02;
00997     if (ok)  ok = Rec.WriteBYTE(Flags);
00998 
00999     if (ok)
01000         pFilter->Write(&Rec);
01001 
01002 #endif // EXCLUDE_FROM_RALPH
01003     return(ok);
01004 }

BOOL PrintComponent::ExportImagesetting (  BaseCamelotFilter *  pFilter  ) 
 

Export a TAG_IMAGESETTING native file record.

Author:
Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
Date:
14/8/96
Parameters:
pFilter - the BaseCamelotFilter filter that is being used to export a file. [INPUTS]
Returns:
TRUE for success
See also:
PrintingRecordHandler

Definition at line 876 of file princomp.cpp.

00877 {
00878     BOOL ok = TRUE;
00879 
00880 #if !defined(EXCLUDE_FROM_RALPH)
00881 
00882     TypesetInfo *TInfo = GetPrintControl()->GetTypesetInfo();
00883     if (TInfo == NULL)
00884         return(TRUE);       // If we can't find imagesetting info, don't sweat it
00885 
00886     CXaraFileRecord Rec(TAG_IMAGESETTING, TAG_IMAGESETTING_SIZE);
00887     if (ok)  ok = Rec.Init();
00888 
00889     if (ok)  ok = Rec.WriteINT32(TInfo->GetPrintResolution());
00890     if (ok)  ok = Rec.WriteDOUBLE(TInfo->GetDefaultScreenFrequency());
00891 
00892     if (ok)
00893     {
00894         UINT16 Func = 0;
00895         switch(TInfo->GetScreenFunction())
00896         {
00897             case SCRTYPE_SPOT1:         Func = 1;   break;
00898             case SCRTYPE_SPOT2:         Func = 2;   break;
00899             case SCRTYPE_TRIPLESPOT1:   Func = 3;   break;
00900             case SCRTYPE_TRIPLESPOT2:   Func = 4;   break;
00901             case SCRTYPE_ELLIPTICAL:    Func = 5;   break;
00902             case SCRTYPE_LINE:          Func = 6;   break;
00903             case SCRTYPE_CROSSHATCH:    Func = 7;   break;
00904             case SCRTYPE_MEZZOTINT:     Func = 8;   break;
00905             case SCRTYPE_SQUARE:        Func = 9;   break;
00906             case SCRTYPE_DITHER:        Func = 10;  break;
00907             default:
00908                 break;
00909         }
00910         ok = Rec.WriteUINT16(Func);
00911     }
00912 
00913     if (ok)
00914     {
00915         BYTE Flags = 0x00;
00916         if (TInfo->AreSeparating())         Flags |= 0x01;
00917         if (TInfo->AreScreening())          Flags |= 0x02;
00918         if (TInfo->PrintEmulsionDown())     Flags |= 0x04;
00919         if (TInfo->PrintPhotoNegative())    Flags |= 0x08;
00920         if (TInfo->AlwaysOverprintBlack())  Flags |= 0x10;
00921 
00922         ok = Rec.WriteBYTE(Flags);
00923     }
00924 
00925     if (ok)
00926         pFilter->Write(&Rec);
00927 
00928 #endif // EXCLUDE_FROM_RALPH
00929     return(ok);
00930 }

BOOL PrintComponent::ExportPrintSettings (  BaseCamelotFilter *  pFilter  ) 
 

Export a TAG_PRINTERSETTINGS native file record.

Author:
Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
Date:
14/8/96
Parameters:
pFilter - the BaseCamelotFilter filter that is being used to export a file. [INPUTS]
Returns:
TRUE for success
See also:
PrintingRecordHandler

Definition at line 731 of file princomp.cpp.

00732 {
00733     BOOL ok = TRUE;
00734 
00735 #if !defined(EXCLUDE_FROM_RALPH)
00736 
00737     // --- Write the record
00738     CXaraFileRecord Rec(TAG_PRINTERSETTINGS, TAG_PRINTERSETTINGS_SIZE);
00739     if (ok) ok = Rec.Init();
00740 
00741     INT32 Value;        // Temp variable used by macros etc
00742 
00743     // --- Macros. These are undefined immediately at the end of this function
00744     // --- Helper macro for safely exporting an enum as a BYTE value: 1, 2. Unknown enums are output as a 1.
00745     #define OutputEnum2(FuncName,A,B)           \
00746         if (ok)                                 \
00747         {                                       \
00748             switch(pPrCtrl->Get##FuncName())    \
00749             {                                   \
00750                 case A: Value=1; break;         \
00751                 case B: Value=2; break;         \
00752                 default: Value=1; ERROR3("Bad enum"); break; \
00753             }                                   \
00754             ok = Rec.WriteBYTE((BYTE)Value);    \
00755         }
00756 
00757     // --- Helper macro for safely exporting an enum as a BYTE value: 1, 2, 3. Unknown enums are output as a 1.
00758     #define OutputEnum3(FuncName,A,B,C)         \
00759         if (ok)                                 \
00760         {                                       \
00761             switch(pPrCtrl->Get##FuncName())    \
00762             {                                   \
00763                 case A: Value=1; break;         \
00764                 case B: Value=2; break;         \
00765                 case C: Value=3; break;         \
00766                 default: Value=1; ERROR3("Bad enum"); break; \
00767             }                                   \
00768             ok = Rec.WriteBYTE((BYTE)Value);    \
00769         }
00770 
00771     // --- Helper macro for safely exporting an enum as a BYTE value: 1, 2, 3. Unknown enums are output as a 1.
00772     #define OutputEnum4(FuncName,A,B,C,D)           \
00773         if (ok)                                 \
00774         {                                       \
00775             switch(pPrCtrl->Get##FuncName())    \
00776             {                                   \
00777                 case A: Value=1; break;         \
00778                 case B: Value=2; break;         \
00779                 case C: Value=3; break;         \
00780                 case D: Value=4; break;         \
00781                 default: Value=1; ERROR3("Bad enum"); break; \
00782             }                                   \
00783             ok = Rec.WriteBYTE((BYTE)Value);    \
00784         }
00785 
00786     // --- Helper macro to output any 32-bit UNsigned value
00787     #define OutputValueU(FuncName)              \
00788         if (ok)  ok = Rec.WriteUINT32((UINT32)pPrCtrl->Get##FuncName());
00789 
00790     // --- Helper macro to output any 32-bit Signed value
00791     #define OutputValueS(FuncName)              \
00792         if (ok)  ok = Rec.WriteINT32((INT32)pPrCtrl->Get##FuncName());
00793 
00794     // --- Helper macro to output any 16-bit UNsigned value
00795     #define OutputValue16(FuncName)             \
00796         if (ok)  ok = Rec.WriteUINT16((UINT16)pPrCtrl->Get##FuncName());
00797 
00798 
00799                                                                                                     // Size Total
00800     OutputValueU(NumCopies);                                                                        // 4    4
00801     if (ok) ok = Rec.WriteFIXED16(pPrCtrl->GetScale());                                             // 4    8
00802     OutputValueS(TopMargin);                                                                        // 4    12
00803     OutputValueS(LeftMargin);                                                                       // 4    16
00804     OutputValueS(Width);                                                                            // 4    20
00805     OutputValueS(Height);                                                                           // 4    24
00806     OutputValue16(Rows);                                                                            // 2    26
00807     OutputValue16(Columns);                                                                         // 2    28
00808     OutputValueS(Gutter);                                                                           // 4    32
00809     OutputEnum3(PrintMethod,        PRINTMETHOD_NORMAL, PRINTMETHOD_BITMAP, PRINTMETHOD_AABITMAP);  // 1    33
00810     OutputEnum2(ObjPrintRange,      PRINTRANGEOBJ_ALL, PRINTRANGEOBJ_SELECTED);                     // 1    34
00811     OutputEnum3(DPSPrintRange,      PRINTRANGEDPS_BOTH, PRINTRANGEDPS_LEFTPAGES, PRINTRANGEDPS_RIGHTPAGES);
00812                                                                                                     // 1    35
00813     OutputEnum2(PrintOrient,        PRINTORIENTATION_UPRIGHT, PRINTORIENTATION_SIDEWAYS);           // 1    36
00814     OutputEnum4(FitType,            PRINTFIT_BEST, PRINTFIT_CUSTOM, PRINTFIT_MULTIPLE, PRINTFIT_BESTPAPER); // 1    37
00815     OutputEnum2(PrintLayers,        PRINTLAYERS_ALLFOREGROUND, PRINTLAYERS_VISIBLEFOREGROUND);      // 1    38
00816     OutputEnum3(PSLevel,            PSLEVEL_AUTO, PSLEVEL_1, PSLEVEL_2);                            // 1    39
00817     OutputEnum2(BitmapResMethod,    BITMAPRES_AUTO, BITMAPRES_MANUAL);                              // 1    40
00818                                                                                                     //
00819     if (ok)                                                                                         //
00820     {                                                                                               //
00821         // If bitmap resolution is automatic, then just output a default of 150dpi for DotsPerInch  //
00822         if (pPrCtrl->GetBitmapResMethod() == BITMAPRES_MANUAL)                                      //
00823             Value = pPrCtrl->GetDotsPerInch();                                                      //
00824         else                                                                                        //
00825             Value = 150;                                                                            //
00826                                                                                                     //
00827         ok = Rec.WriteUINT32((UINT32) Value);                                                           // 4    44
00828     }                                                                                               //
00829                                                                                                     //
00830     if (ok)                                                                                         //
00831     {                                                                                               //
00832         Value = 0x00;                                                                               //
00833         if (pPrCtrl->IsCollated())          Value |= 0x01;                                          //
00834         if (pPrCtrl->IsWholeSpread())       Value |= 0x02;                                          //
00835         if (pPrCtrl->GetPrintToFile())      Value |= 0x04;                                          //
00836         if (pPrCtrl->GetTextOptions() == PRINTTEXTOPTIONS_ALLTEXTASSHAPES)                          //
00837             Value |= 0x08;                                                                          //
00838                                                                                                     //
00839         ok = Rec.WriteBYTE((BYTE)Value);                                                            // 1    45 TOTAL
00840     }
00841 
00842     // --- Finally, output the record
00843     if (ok)
00844         pFilter->Write(&Rec);
00845 
00846 
00847     // Undefine the macros we were using
00848     #undef OutputEnum2
00849     #undef OutputEnum3
00850     #undef OutputValueU
00851     #undef OutputValueS
00852     #undef OutputValue16
00853 #endif // EXCLUDE_FROM_RALPH
00854 
00855     return(ok);
00856 }

void PrintComponent::ExtractTokenValStr (  const char *  pComment  )  [private]
 

The string representation of the token value is stored in Buffer. If no value is found, or the buffer overflows, Buffer will contain an empty string.

Author:
Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
Date:
5/4/95 Input: pComment = ptr to an EPS comment
Returns:
-
See also:
PrintComponent

Definition at line 359 of file princomp.cpp.

00360 {
00361     Buffer[0] = '\0';
00362 
00363     if (pComment != NULL)
00364     {
00365         UINT32 i=0;
00366 
00367         // Skip past token str, up to first space char or string terminating char
00368         while (!camIsspace(pComment[i]) && !camIscntrl(pComment[i]))
00369             i++;
00370 
00371         // Find next non-space char
00372         while (camIsspace(pComment[i]))
00373             i++;
00374 
00375         // Extract all the remaining printable characters
00376         UINT32 j=0;
00377         while (camIsprint(pComment[i]) && j < PC_BUFFERSIZE)
00378             Buffer[j++] = pComment[i++];
00379 
00380         if (j >= PC_BUFFERSIZE)
00381             j=0;
00382 
00383         Buffer[j] = '\0';
00384     }
00385 }

PrintControl* PrintComponent::GetPrintControl (   )  [inline]
 

Definition at line 186 of file princomp.h.

00186 { return pPrCtrl; }

PCToken PrintComponent::GetToken (  const char *  pComment  )  [private]
 

Outputs a print component token with the given value.

Author:
Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
Date:
5/4/95 Input: pComment = ptr to an EPS comment
Returns:
The print component token value
See also:
PrintComponent

Definition at line 324 of file princomp.cpp.

00325 {
00326     UINT32 i;
00327 
00328     for (i=0;!camIsspace(pComment[i]) && i < PC_BUFFERSIZE;i++)
00329         Buffer[i] = pComment[i];
00330 
00331     if (i >= PC_BUFFERSIZE)
00332         i=0;
00333 
00334     Buffer[i] = '\0';
00335 
00336     for (i=0;i < PCTOKEN_UNKNOWN;i++)
00337     {
00338         if (camStrcmp(PCTokenStr[i],Buffer) == 0)
00339             return (PCToken)i;
00340     }
00341 
00342     return PCTOKEN_UNKNOWN;
00343 }

FIXED16 PrintComponent::GetTokenValFIXED16 (  const char *  pComment  )  [private]
 

This gets the value after the token part of the comment and returns it as a FIXED16.

Author:
Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
Date:
5/4/95 Input: pComment = ptr to an EPS comment
Returns:
-
See also:
PrintComponent

Definition at line 424 of file princomp.cpp.

00425 {
00426     ExtractTokenValStr(pComment);
00427 
00428     double n = 0.0;
00429     camSscanf( Buffer, _T("%le"), &n );
00430 
00431     if (n > double(0x7fff))
00432         n = double(0x7fff);
00433 
00434     if (n < double(-0x8000))
00435         n = double(-0x8000);
00436 
00437     return FIXED16(n);
00438 }

INT32 PrintComponent::GetTokenValINT32 (  const char *  pComment  )  [private]
 

This gets the value after the token part of the comment and returns it as a INT32.

Author:
Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
Date:
5/4/95 Input: pComment = ptr to an EPS comment
Returns:
-
See also:
PrintComponent

Definition at line 400 of file princomp.cpp.

00401 {
00402     ExtractTokenValStr(pComment);
00403 
00404     INT32 n = 0;
00405     camSscanf( Buffer, _T("%ld"), &n );
00406 
00407     return n;
00408 }

void PrintComponent::ImportColourPlate (  CXaraFileRecord *  Rec,
CamelotRecordHandler *  pHandler
) 
 

Load a TAG_COLOURPLATE native file record.

Author:
Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
Date:
14/8/96
Parameters:
Rec - the record to be imported [INPUTS] pHandler - The 'andler wot's callin' me, so's I can find me spot culler.
Notes: To correctly set up all plates, the TypesetInfo should have been correctly set up (by loading a TAG_IMAGESETTING record). This is because some ColourPlate settings are regenerated from entries saved in the TAG_IMAGESETTING record.

See also:
PrintingRecordHandler

Definition at line 1285 of file princomp.cpp.

01286 {
01287 #if !defined(EXCLUDE_FROM_RALPH)
01288     BOOL ok = TRUE;
01289 
01290     PORTNOTETRACE("print","PrintComponent::ImportColourPlate - do nothing");
01291     TypesetInfo *TInfo = GetPrintControl()->GetTypesetInfo();
01292     if (TInfo == NULL)
01293         return;
01294     
01295     ColourPlate *NewPlate = TInfo->CreateColourPlate();
01296     if (NewPlate == NULL)
01297         return;
01298 
01299     BYTE Type;
01300     if (ok)  ok = Rec->ReadBYTE(&Type);
01301 
01302     ColourPlateType PlateType = COLOURPLATE_NONE;
01303     if (ok)
01304     {
01305         switch(Type)
01306         {
01307             case 1: PlateType = COLOURPLATE_CYAN;       break;
01308             case 2: PlateType = COLOURPLATE_MAGENTA;    break;
01309             case 3: PlateType = COLOURPLATE_YELLOW;     break;
01310             case 4: PlateType = COLOURPLATE_KEY;        break;
01311             case 5: PlateType = COLOURPLATE_SPOT;       break;
01312         }
01313     }
01314 
01315     IndexedColour *pCol = NULL;
01316     if (ok)
01317     {
01318         INT32 ColRecordNum;
01319         ok = Rec->ReadINT32(&ColRecordNum);
01320         if (ok && PlateType == COLOURPLATE_SPOT)
01321         {
01322             DocColour SpotCol;
01323             ok = pHandler->GetDocColour(ColRecordNum, &SpotCol);
01324             if (ok)
01325                 pCol = SpotCol.FindParentIndexedColour();
01326         }
01327     }
01328 
01329     // If this is a spot plate, it must reference a valid spot colour
01330     if (PlateType == COLOURPLATE_SPOT &&
01331         (pCol == NULL || pCol->GetType() != COLOURTYPE_SPOT || pCol->IsDeleted()) )
01332     {
01333         // Poohs. No point in keeping this plate around
01334         delete NewPlate;
01335         return;
01336     }
01337 
01338     NewPlate->SetType(NULL, PlateType, pCol);
01339 
01340     if (ok)
01341     {
01342         double Angle = 0.0;
01343         double Frequency = 60.0;
01344 
01345         ok = Rec->ReadDOUBLE(&Angle);
01346         if (ok)  ok = Rec->ReadDOUBLE(&Frequency);
01347         if (ok)  NewPlate->SetScreenInfo(Angle, Frequency);
01348     }
01349 
01350     BYTE Flags;
01351     if (ok)  ok = Rec->ReadBYTE(&Flags);
01352 
01353     if (ok)
01354     {
01355         NewPlate->SetDisabled( (Flags & 0x01) == 0);        // NOTE Flag is ENabled state!
01356         NewPlate->SetOverprint((Flags & 0x02) != 0);
01357     }
01358 
01359 
01360     if (ok)
01361     {
01362         // Now, it'll be quite handy if we add the new plate to the plate list!
01363         TInfo->AddPlate(NewPlate);
01364     }
01365 #endif
01366 }

void PrintComponent::ImportImagesetting (  CXaraFileRecord *  Rec  ) 
 

Load a TAG_IMAGESETTING native file record.

Author:
Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
Date:
14/8/96
Parameters:
Rec - the record to be imported [INPUTS]
See also:
PrintingRecordHandler

Definition at line 1195 of file princomp.cpp.

01196 {
01197 #if !defined(EXCLUDE_FROM_RALPH)
01198     PORTNOTETRACE("print","PrintComponent::ImportImagesetting - do nothing");
01199     TypesetInfo *TInfo = GetPrintControl()->GetTypesetInfo();
01200     if (TInfo == NULL)
01201         return;
01202 
01203     // Vape any colour plates already resident in the typeset info
01204     TInfo->DestroyPlateList();
01205 
01206     BOOL ok = TRUE;
01207 
01208     if (ok)
01209     {
01210         INT32 Res;
01211         ok = Rec->ReadINT32(&Res);
01212         if (ok)  TInfo->SetPrintResolution(Res);
01213     }
01214 
01215     if (ok)
01216     {
01217         double Freq;
01218         ok = Rec->ReadDOUBLE(&Freq);
01219         if (ok)  TInfo->SetDefaultScreenFrequency(Freq);
01220     }
01221 
01222     if (ok)
01223     {
01224         UINT16 Func;
01225         ok = Rec->ReadUINT16(&Func);
01226 
01227         if (ok)
01228         {
01229             ScreenType Screen = SCRTYPE_NONE;
01230             switch(Func)
01231             {
01232                 case 1: Screen = SCRTYPE_SPOT1;         break;
01233                 case 2: Screen = SCRTYPE_SPOT2;         break;
01234                 case 3: Screen = SCRTYPE_TRIPLESPOT1;   break;
01235                 case 4: Screen = SCRTYPE_TRIPLESPOT2;   break;
01236                 case 5: Screen = SCRTYPE_ELLIPTICAL;    break;
01237                 case 6: Screen = SCRTYPE_LINE;          break;
01238                 case 7: Screen = SCRTYPE_CROSSHATCH;    break;
01239                 case 8: Screen = SCRTYPE_MEZZOTINT;     break;
01240                 case 9: Screen = SCRTYPE_SQUARE;        break;
01241                 case 0: Screen = SCRTYPE_DITHER;        break;
01242             }
01243             TInfo->SetScreenFunction(Screen, TRUE);
01244         }
01245     }
01246 
01247     if (ok)
01248     {
01249         BYTE Flags;
01250         ok = Rec->ReadBYTE(&Flags);
01251 
01252         TInfo->SetSeparations(  (Flags & 0x01) != 0);
01253         TInfo->SetOutputPrintersMarks(TInfo->AreSeparating());  // Slave Printers Marks off the Seps flag
01254 
01255         TInfo->SetScreening(    (Flags & 0x02) != 0);
01256         TInfo->SetEmulsionDown( (Flags & 0x04) != 0);
01257         TInfo->SetPhotoNegative((Flags & 0x08) != 0);
01258         TInfo->SetOverprintBlack((Flags & 0x10) != 0);
01259     } 
01260 #endif
01261 }

void PrintComponent::ImportPrintSettings (  CXaraFileRecord *  Rec  ) 
 

Load a TAG_PRINTERSETTINGS native file record.

Author:
Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
Date:
14/8/96
Parameters:
pCXaraFileRecord - the record to be imported [INPUTS]
See also:
PrintingRecordHandler

Definition at line 1022 of file princomp.cpp.

01023 {
01024 #if !defined(EXCLUDE_FROM_RALPH)
01025     BOOL ok = TRUE;
01026 
01027     PORTNOTETRACE("print","PrintComponent::ImportPrintSettings - do nothing");
01028     // Let the print control object know we are importing the data rather than changing it via UI
01029     // This makes sure that setting some values does not auto-update other values!
01030     pPrCtrl->StartImport();
01031 
01032     // --- Macros. These are undefined immediately at the end of this function
01033     // --- Helper macro for safely importing an enum stored as a BYTE value: 1, 2.
01034     //     Unknown enums are ignored - i.e. they retain the default program setting
01035     #define InputEnum2(FuncName,A,B)                            \
01036         if (ok)                                                 \
01037         {                                                       \
01038             BYTE Value;                                         \
01039             ok = Rec->ReadBYTE(&Value);                         \
01040             if (ok)                                             \
01041             {                                                   \
01042                 switch(Value)                                   \
01043                 {                                               \
01044                     case 1: pPrCtrl->Set##FuncName(A); break;   \
01045                     case 2: pPrCtrl->Set##FuncName(B); break;   \
01046                     default: ERROR3("Bad enum"); break;         \
01047                 }                                               \
01048             }                                                   \
01049         }
01050 
01051     // --- Helper macro for safely exporting an enum as a BYTE value: 1, 2, 3. Unknown enums are Input as a 1.
01052     #define InputEnum3(FuncName,A,B,C)                          \
01053         if (ok)                                                 \
01054         {                                                       \
01055             BYTE Value;                                         \
01056             ok = Rec->ReadBYTE(&Value);                         \
01057             if (ok)                                             \
01058             {                                                   \
01059                 switch(Value)                                   \
01060                 {                                               \
01061                     case 1: pPrCtrl->Set##FuncName(A); break;   \
01062                     case 2: pPrCtrl->Set##FuncName(B); break;   \
01063                     case 3: pPrCtrl->Set##FuncName(C); break;   \
01064                     default: ERROR3("Bad enum"); break;         \
01065                 }                                               \
01066             }                                                   \
01067         }
01068 
01069     // --- Helper macro for safely exporting an enum as a BYTE value: 1, 2, 3. Unknown enums are Input as a 1.
01070     #define InputEnum4(FuncName,A,B,C,D)                        \
01071         if (ok)                                                 \
01072         {                                                       \
01073             BYTE Value;                                         \
01074             ok = Rec->ReadBYTE(&Value);                         \
01075             if (ok)                                             \
01076             {                                                   \
01077                 switch(Value)                                   \
01078                 {                                               \
01079                     case 1: pPrCtrl->Set##FuncName(A); break;   \
01080                     case 2: pPrCtrl->Set##FuncName(B); break;   \
01081                     case 3: pPrCtrl->Set##FuncName(C); break;   \
01082                     case 4: pPrCtrl->Set##FuncName(D); break;   \
01083                     default: ERROR3("Bad enum"); break;         \
01084                 }                                               \
01085             }                                                   \
01086         }
01087 
01088     // --- Helper macro to Input any 32-bit UNsigned value
01089     #define InputValueU(FuncName)                               \
01090         if (ok)                                                 \
01091         {                                                       \
01092             UINT32 Value;                                       \
01093             ok = Rec->ReadUINT32(&Value);                       \
01094             if (ok)  pPrCtrl->Set##FuncName(Value);             \
01095         }                                                       \
01096 
01097     // --- Helper macro to Input any 32-bit Signed value
01098     #define InputValueS(FuncName)                               \
01099         if (ok)                                                 \
01100         {                                                       \
01101             INT32 Value;                                            \
01102             ok = Rec->ReadINT32(&Value);                            \
01103             if (ok)  pPrCtrl->Set##FuncName(Value);             \
01104         }                                                       \
01105 
01106     // --- Helper macro to Input any 16-bit UNsigned value (NOTE: Casts the result to a INT32)
01107     #define InputValue16(FuncName)                              \
01108         if (ok)                                                 \
01109         {                                                       \
01110             UINT16 Value;                                       \
01111             ok = Rec->ReadUINT16(&Value);                       \
01112             if (ok)  pPrCtrl->Set##FuncName((INT32)Value);      \
01113         }                                                       \
01114     
01115 
01116     // --- Read the record
01117     InputValueU(NumCopies);
01118     if (ok)
01119     {
01120         FIXED16 Value;
01121         ok = Rec->ReadFIXED16(&Value);
01122         if (ok)  pPrCtrl->SetScale(Value);
01123     }
01124     InputValueS(TopMargin);
01125     InputValueS(LeftMargin);
01126     InputValueS(Width); 
01127     InputValueS(Height);
01128     InputValue16(Rows);
01129     InputValue16(Columns);
01130     InputValueS(Gutter);
01131     InputEnum3(PrintMethod,     PRINTMETHOD_NORMAL, PRINTMETHOD_BITMAP, PRINTMETHOD_AABITMAP);
01132     InputEnum2(ObjPrintRange,   PRINTRANGEOBJ_ALL, PRINTRANGEOBJ_SELECTED);
01133     InputEnum3(DPSPrintRange,   PRINTRANGEDPS_BOTH, PRINTRANGEDPS_LEFTPAGES, PRINTRANGEDPS_RIGHTPAGES);
01134     InputEnum2(PrintOrient,     PRINTORIENTATION_UPRIGHT, PRINTORIENTATION_SIDEWAYS);
01135     InputEnum4(FitType,         PRINTFIT_BEST, PRINTFIT_CUSTOM, PRINTFIT_MULTIPLE, PRINTFIT_BESTPAPER);
01136     InputEnum2(PrintLayers,     PRINTLAYERS_ALLFOREGROUND, PRINTLAYERS_VISIBLEFOREGROUND);
01137 // Dirty bodge to ensure that all loaded XAR files use PSLEVEL_2
01138 // Job 10463: remove PS Level bits - default to Level 2
01139 //  InputEnum3(PSLevel,         PSLEVEL_AUTO, PSLEVEL_1, PSLEVEL_2);
01140     InputEnum3(PSLevel,         PSLEVEL_2, PSLEVEL_2, PSLEVEL_2);
01141     InputEnum2(BitmapResMethod, BITMAPRES_AUTO, BITMAPRES_MANUAL);
01142 
01143     if (ok)
01144     {
01145         UINT32 Value;
01146         ok = Rec->ReadUINT32(&Value);
01147         if (ok)  pPrCtrl->SetDotsPerInch(Value);
01148     }
01149 
01150     if (ok)
01151     {
01152         BYTE Value;
01153         ok = Rec->ReadBYTE(&Value);
01154 
01155         if (ok)
01156         {
01157             pPrCtrl->SetCollated(   (Value & 0x01) != 0);   // Bit 1 indicates collated
01158             pPrCtrl->SetWholeSpread((Value & 0x02) != 0);   // Bit 2 indicates whole spread
01159             pPrCtrl->SetPrintToFile((Value & 0x04) != 0);   // Bit 3 indicates print-to-file
01160 
01161             pPrCtrl->SetTextOptions(((Value & 0x08) != 0) ? PRINTTEXTOPTIONS_ALLTEXTASSHAPES : PRINTTEXTOPTIONS_NORMAL);
01162                                                             // Bit 4 indicates print-text-as-shapes
01163         }
01164     }
01165 
01166     // Let the print control object know we have finished importing (for the moment at least)
01167     pPrCtrl->EndImport();
01168 
01169     // Undefine the macros we were using
01170     #undef InputEnum2
01171     #undef InputEnum3
01172     #undef InputValueU
01173     #undef InputValueS
01174     #undef InputValue16
01175 
01176 #endif
01177 }

BOOL PrintComponent::OutputValue (  UINT32  Token,
FIXED16  Value
)  [private]
 

Definition at line 471 of file princomp.cpp.

00472 {
00473     ERROR2IF(pExportDC == NULL,FALSE,"NULL export DC in PrintComponent::OutputValue()");
00474     ERROR2IF(Token >= PCTOKEN_UNKNOWN,FALSE,"Token out of range");
00475 
00476     BOOL ok = TRUE;
00477 
00478     if (ok) ok = pExportDC->OutputToken(PCTokenStr[Token]);
00479     if (ok) ok = pExportDC->OutputReal(Value.MakeDouble());
00480     if (ok) ok = pExportDC->OutputNewLine();
00481     return ok;
00482 }

BOOL PrintComponent::OutputValue (  UINT32  Token,
INT32  Value
)  [private]
 

Outputs a print component token with the given value.

Author:
Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
Date:
31/3/95 Input: Token = the print component token to output Value = the value to output after the token
Returns:
TRUE if successful, FALSE if failed
See also:
PrintComponent

Definition at line 456 of file princomp.cpp.

00457 {
00458     ERROR2IF(pExportDC == NULL,FALSE,"NULL export DC in PrintComponent::OutputValue()");
00459     ERROR2IF(Token >= PCTOKEN_UNKNOWN,FALSE,"Token out of range");
00460 
00461     BOOL ok = TRUE;
00462 
00463     if (ok) ok = pExportDC->OutputToken(PCTokenStr[Token]);
00464     if (ok) ok = pExportDC->OutputValue(Value);
00465     if (ok) ok = pExportDC->OutputNewLine();
00466 
00467     return ok;
00468 }

ProcessEPSResult PrintComponent::ProcessEPSComment (  EPSFilter *  pFilter,
const char *  pComment
)  [virtual]
 

Process an EPS comment - if this is a print component comment, this component will claim it and try to decode it.

Author:
Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
Date:
31/3/95
Parameters:
pFilter - the EPS filter that is being used to import a file. [INPUTS] pComment - pointer to the comment to process.
Returns:
EPSCommentUnknown - This EPS comment is not recognised by the document component. EPSCommentSyntaxError - This EPS comment was recognised by this document component, but it contained an error. EPSCommentSystemError - This EPS comment was recognised by this document component, but an error occured that was not caused directly by the comment, e.g. out of memory. EPSCommentOK - This EPS comment was recognised as a legal comment by this document component, and was processed successfully.

Errors: Badly formed EPS comment.

See also:
DocComponent::ProcessEPSComment

Reimplemented from DocComponent.

Definition at line 591 of file princomp.cpp.

00593 {
00594     ERROR2IF(pPrCtrl == NULL,EPSCommentUnknown,"No print control to output in PrintComponent::ProcessEPSComment()");
00595 
00596     ProcessEPSResult Result = EPSCommentUnknown;
00597 
00598     PCToken Token = GetToken(pComment);
00599 
00600     if (Token != PCTOKEN_UNKNOWN)
00601     {
00602         // Let the print control object know we are importing the data rather than changing it via UI
00603         pPrCtrl->StartImport();
00604 
00605         Result = EPSCommentOK;
00606 
00607         INT32   n     = GetTokenValINT32(pComment);
00608         FIXED16 Scale = GetTokenValFIXED16(pComment);
00609 
00610         switch (Token)
00611         {
00612             case PCTOKEN_SECTIONNAME:
00613                 // 'n' is the version number for this comment block
00614                 if (n != PC_SECTION_VERSION)
00615                     Result = EPSCommentSyntaxError;
00616                 break;
00617 
00618             case PCTOKEN_WHOLESPREAD:       pPrCtrl->SetWholeSpread(n);                         break;
00619             case PCTOKEN_SCALE:             pPrCtrl->SetScale(Scale);                           break;
00620             case PCTOKEN_ORIENTATION:       pPrCtrl->SetPrintOrient(PrintOrient(n));            break;
00621             case PCTOKEN_FITTYPE:           pPrCtrl->SetFitType(PrintFitType(n));               break;
00622             case PCTOKEN_TOPMARGIN:         pPrCtrl->SetTopMargin(n);                           break;
00623             case PCTOKEN_LEFTMARGIN:        pPrCtrl->SetLeftMargin(n);                          break;
00624             case PCTOKEN_WIDTH:             pPrCtrl->SetWidth(n);                               break;
00625             case PCTOKEN_HEIGHT:            pPrCtrl->SetHeight(n);                              break;
00626             case PCTOKEN_ROWS:              pPrCtrl->SetRows(n);                                break;
00627             case PCTOKEN_COLUMNS:           pPrCtrl->SetColumns(n);                             break;
00628             case PCTOKEN_GUTTER:            pPrCtrl->SetGutter(n);                              break;
00629             case PCTOKEN_LAYERS:            pPrCtrl->SetPrintLayers(PrintLayers(n));            break;
00630 // Dirty bodge to ensure that PSLevel is always 2
00631 // Job 10463: remove PS Level bits - default to Level 2
00632 //          case PCTOKEN_PSLEVEL:           pPrCtrl->SetPSLevel(PSLevel(n));                    break;
00633             case PCTOKEN_PSLEVEL:           pPrCtrl->SetPSLevel(PSLEVEL_2);                     break;
00634             case PCTOKEN_BITMAPRESMETHOD:   pPrCtrl->SetBitmapResMethod(BitmapResMethod(n));    break;
00635             case PCTOKEN_DOTSPERINCH:       pPrCtrl->SetDotsPerInch(n);                         break;
00636             case PCTOKEN_COLLATED:          pPrCtrl->SetCollated(n);                            break;
00637             case PCTOKEN_NUMCOPIES:         pPrCtrl->SetNumCopies(n);                           break;
00638             case PCTOKEN_PRINTTOFILE:       pPrCtrl->SetPrintToFile(n);                         break;
00639             case PCTOKEN_OBJPRINTRANGE:     pPrCtrl->SetObjPrintRange(PrintRangeObj(n));        break;
00640             case PCTOKEN_DPSPRINTRANGE:     pPrCtrl->SetDPSPrintRange(PrintRangeDPS(n));        break;
00641             case PCTOKEN_ALLTEXTASSHAPES:   pPrCtrl->SetTextOptions((PrintTextOptions) n);      break;
00642 //          case PCTOKEN_PRINTMETHOD:       pPrCtrl->SetPrintMethod(PrintMethodType(n));        break;
00643             default:
00644                 break;
00645         }
00646 
00647         // Let the print control object know we have finished importing (for the moment at least)
00648         pPrCtrl->EndImport();
00649     }
00650     return Result;
00651 }

BOOL PrintComponent::WriteEPSComments (  EPSFilter *  pFilter  )  [virtual]
 

Writes out the print control object in the form of EPS comments in the 'header' comments of the EPS file.

Author:
Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
Date:
31/3/95
Parameters:
pFilter - the filter being used to import the EPS file. [INPUTS]
Returns:
TRUE if the print control object was written successfully; FALSE if not.

Errors: Out of disk space, and similar disk errors.

See also:
DocComponent::WriteEPSComments; DocComponent

Reimplemented from DocComponent.

Definition at line 501 of file princomp.cpp.

00502 {
00503     // Graeme (23-5-00) - Neither AI nor ArtWorks files need the print control entries, so
00504     // just return TRUE to avoid problems.
00505     if ( !pFilter->NeedsPrintComponents () )
00506     {
00507         return TRUE;
00508     }
00509 
00510     ERROR2IF ( pPrCtrl == NULL, FALSE,
00511               "No print control to output in PrintComponent::WriteEPSComments()" );
00512 
00513 
00514     // Set up the export DC ptr
00515     pExportDC = pFilter->GetExportDC();
00516 
00517     ERROR2IF(pExportDC == NULL,FALSE,"Export DC is NULL in PrintComponent::WriteEPSComments()");
00518 
00519     BOOL ok = TRUE;
00520 
00521     if (ok) ok = OutputValue(PCTOKEN_SECTIONNAME,       PC_SECTION_VERSION);
00522 
00523     if (ok) ok = OutputValue(PCTOKEN_WHOLESPREAD,       pPrCtrl->IsWholeSpread());
00524     if (ok) ok = OutputValue(PCTOKEN_SCALE,             pPrCtrl->GetScale());
00525     if (ok) ok = OutputValue(PCTOKEN_ORIENTATION,       pPrCtrl->GetPrintOrient());
00526     if (ok) ok = OutputValue(PCTOKEN_FITTYPE,           pPrCtrl->GetFitType());
00527     if (ok) ok = OutputValue(PCTOKEN_TOPMARGIN,         pPrCtrl->GetTopMargin());
00528     if (ok) ok = OutputValue(PCTOKEN_LEFTMARGIN,        pPrCtrl->GetLeftMargin());
00529     if (ok) ok = OutputValue(PCTOKEN_WIDTH,             pPrCtrl->GetWidth());
00530     if (ok) ok = OutputValue(PCTOKEN_HEIGHT,            pPrCtrl->GetHeight());
00531     if (ok) ok = OutputValue(PCTOKEN_ROWS,              pPrCtrl->GetRows());
00532     if (ok) ok = OutputValue(PCTOKEN_COLUMNS,           pPrCtrl->GetColumns());
00533     if (ok) ok = OutputValue(PCTOKEN_GUTTER,            pPrCtrl->GetGutter());
00534     if (ok) ok = OutputValue(PCTOKEN_LAYERS,            pPrCtrl->GetPrintLayers());
00535     if (ok) ok = OutputValue(PCTOKEN_PSLEVEL,           pPrCtrl->GetPSLevel());
00536     if (ok) ok = OutputValue(PCTOKEN_BITMAPRESMETHOD,   pPrCtrl->GetBitmapResMethod());
00537 
00538     // We only need to output the bitmap DPI if the user has selected 'manual' bitmap DPI
00539     // Auto DPI will calculated the DPI automatically ( surprise, surprise - Cilla 'ere!)
00540     // This also means that the printer's DPI is not needed before saving, hence avoiding any unnecessary
00541     // delays.
00542     if (ok)
00543     {
00544         if (pPrCtrl->GetBitmapResMethod() == BITMAPRES_MANUAL)
00545             ok = OutputValue(PCTOKEN_DOTSPERINCH, pPrCtrl->GetDotsPerInch());
00546         else
00547             ok = OutputValue(PCTOKEN_DOTSPERINCH, 150);
00548     }
00549 
00550     if (ok) ok = OutputValue(PCTOKEN_COLLATED,          pPrCtrl->IsCollated());
00551     if (ok) ok = OutputValue(PCTOKEN_NUMCOPIES,         pPrCtrl->GetNumCopies());
00552     if (ok) ok = OutputValue(PCTOKEN_PRINTTOFILE,       pPrCtrl->GetPrintToFile());
00553     if (ok) ok = OutputValue(PCTOKEN_OBJPRINTRANGE,     pPrCtrl->GetObjPrintRange());
00554     if (ok) ok = OutputValue(PCTOKEN_DPSPRINTRANGE,     pPrCtrl->GetDPSPrintRange());
00555     if (ok) ok = OutputValue(PCTOKEN_ALLTEXTASSHAPES,   pPrCtrl->GetTextOptions());
00556 //  if (ok) ok = OutputValue(PCTOKEN_PRINTMETHOD,       pPrCtrl->GetPrintMethod());
00557 
00558     // reset the DC ptr to NULL (ready for next time)
00559     pExportDC = NULL;
00560 
00561     return ok;
00562 }


Member Data Documentation

TCHAR PrintComponent::Buffer[32] [private]
 

Definition at line 220 of file princomp.h.

EPSExportDC* PrintComponent::pExportDC [private]
 

Definition at line 219 of file princomp.h.

PrintControl* PrintComponent::pPrCtrl [private]
 

Definition at line 218 of file princomp.h.


The documentation for this class was generated from the following files:
Generated on Sat Nov 10 03:59:59 2007 for Camelot by  doxygen 1.4.4