Beispiel #1
0
        //--------------------------------------------------------------------//
        //                                                        M e t h o d //
        // g e n e r a t e J o b H e a d e r                                  //
        //--------------------------------------------------------------------//
        //                                                                    //
        // Write stream initialisation sequences to output file.              //
        //                                                                    //
        //--------------------------------------------------------------------//

        private static void generateJobHeader(
            BinaryWriter prnWriter,
            Int32 indxPaperSize,
            Int32 indxPaperType,
            Int32 indxOrientation,
            Int32 indxPlexMode,
            Boolean flagSimplexJob,
            Boolean flagMainEncapsulated,
            Boolean flagRearEncapsulated,
            Boolean flagStreamRemove,
            Boolean flagMainForm,
            Boolean flagRearForm,
            String formFileMain,
            String formFileRear,
            eStreamMethod indxMethod,
            String formNameMain,
            String formNameRear)
        {
            PCLXLWriter.stdJobHeader(prnWriter, "");

            if (flagMainForm)
            {
                //------------------------------------------------------------//
                //                                                            //
                // Main (or only) form in use.                                //
                // Download contents of specified file.                       //
                //                                                            //
                //------------------------------------------------------------//

                PCLXLDownloadStream.streamFileEmbed(prnWriter,
                                                    formFileMain,
                                                    formNameMain,
                                                    flagMainEncapsulated);
            }

            if (!flagSimplexJob)
            {
                if (flagRearForm)
                {
                    //--------------------------------------------------------//
                    //                                                        //
                    // Rear form in use.                                      //
                    // Download contents of specified file.                   //
                    //                                                        //
                    //--------------------------------------------------------//

                    PCLXLDownloadStream.streamFileEmbed(prnWriter,
                                                        formFileRear,
                                                        formNameRear,
                                                        flagRearEncapsulated);
                }
            }
        }
        //--------------------------------------------------------------------//
        //                                                        M e t h o d //
        // g e n e r a t e J o b H e a d e r                                  //
        //--------------------------------------------------------------------//
        //                                                                    //
        // Write stream initialisation sequences to output file.              //
        //                                                                    //
        //--------------------------------------------------------------------//

        private static void generateJobHeader(BinaryWriter prnWriter)
        {
            PCLXLWriter.stdJobHeader(prnWriter, "");
        }
        //--------------------------------------------------------------------//
        //                                                        M e t h o d //
        // g e n e r a t e J o b H e a d e r                                  //
        //--------------------------------------------------------------------//
        //                                                                    //
        // Write stream initialisation sequences to output file.              //
        //                                                                    //
        //--------------------------------------------------------------------//

        private static void generateJobHeader(BinaryWriter prnWriter,
                                              Int32 paperSize,
                                              Int32 paperType,
                                              Int32 orientation)
        {
            const Int32 sizeStd = 1024;

            Byte[] bufStd = new Byte[sizeStd];

            Int32 indStd;

            PCLXLWriter.stdJobHeader(prnWriter, "");

            indStd = 0;

            if (orientation < PCLOrientations.getCount())
            {
                PCLXLWriter.addAttrUbyte(ref bufStd,
                                         ref indStd,
                                         PCLXLAttributes.eTag.Orientation,
                                         PCLOrientations.getIdPCLXL(orientation));
            }

            if (paperSize < PCLPaperSizes.getCount())
            {
                PCLXLWriter.addAttrUbyte(ref bufStd,
                                         ref indStd,
                                         PCLXLAttributes.eTag.MediaSize,
                                         PCLPaperSizes.getIdPCLXL(paperSize));
            }

            if ((paperType < PCLPaperTypes.getCount()) &&
                (PCLPaperTypes.getType(paperType) !=
                 PCLPaperTypes.eEntryType.NotSet))
            {
                PCLXLWriter.addAttrUbyteArray(ref bufStd,
                                              ref indStd,
                                              PCLXLAttributes.eTag.MediaType,
                                              PCLPaperTypes.getName(paperType));
            }

            PCLXLWriter.addAttrUbyte(ref bufStd,
                                     ref indStd,
                                     PCLXLAttributes.eTag.SimplexPageMode,
                                     (Byte)PCLXLAttrEnums.eVal.eSimplexFrontSide);

            PCLXLWriter.addOperator(ref bufStd,
                                    ref indStd,
                                    PCLXLOperators.eTag.BeginPage);

            PCLXLWriter.addAttrUint16XY(ref bufStd,
                                        ref indStd,
                                        PCLXLAttributes.eTag.PageOrigin,
                                        0, 0);

            PCLXLWriter.addOperator(ref bufStd,
                                    ref indStd,
                                    PCLXLOperators.eTag.SetPageOrigin);

            PCLXLWriter.addAttrUbyteArray(ref bufStd,
                                          ref indStd,
                                          PCLXLAttributes.eTag.RGBColor,
                                          3, PCLXLWriter.rgbBlack);

            PCLXLWriter.addOperator(ref bufStd,
                                    ref indStd,
                                    PCLXLOperators.eTag.SetBrushSource);

            PCLXLWriter.addAttrUbyteArray(ref bufStd,
                                          ref indStd,
                                          PCLXLAttributes.eTag.RGBColor,
                                          3, PCLXLWriter.rgbBlack);

            PCLXLWriter.addOperator(ref bufStd,
                                    ref indStd,
                                    PCLXLOperators.eTag.SetPenSource);

            prnWriter.Write(bufStd, 0, indStd);
        }