Exemple #1
0
        /// <summary>
        /// Merges delta PrintTicket with base PrintTicket and then validates the merged PrintTicket.
        /// </summary>
        /// <param name="basePrintTicket">The MemoryStream that contains base XML PrintTicket.</param>
        /// <param name="deltaPrintTicket">The MemoryStream that contains delta XML PrintTicket.</param>
        /// <param name="scope">scope that delta PrintTicket and result PrintTicket will be limited to</param>
        /// <param name="conflictStatus">The returned conflict resolving status.</param>
        /// <returns>MemoryStream that contains validated and merged PrintTicket XML.</returns>
        /// <exception cref="ObjectDisposedException">
        /// The PTProvider instance has already been disposed.
        /// </exception>
        /// <exception cref="ArgumentException">
        /// The base PrintTicket specified by <paramref name="basePrintTicket"/> is not well-formed,
        /// or delta PrintTicket specified by <paramref name="deltaPrintTicket"/> is not well-formed.
        /// </exception>
        /// <exception cref="PrintQueueException">
        /// The PTProvider instance failed to merge and validate the input PrintTicket(s).
        /// </exception>
        public override MemoryStream MergeAndValidatePrintTicket(MemoryStream basePrintTicket,
                                                                 MemoryStream deltaPrintTicket,
                                                                 PrintTicketScope scope,
                                                                 out ConflictStatus conflictStatus)
        {
            VerifyAccess();

            DevModeFields supportedFields = DevModeFields.All;
            DevMode       defaultDevMode  = GetDEVMODE(BaseDevModeType.PrinterDefault);

            InternalPrintTicket baseTicket  = (basePrintTicket != null) ? new InternalPrintTicket(basePrintTicket) : null;
            DevMode             baseDevMode = defaultDevMode.Clone();

            PrintTicketToDevMode(baseDevMode, baseTicket, scope, supportedFields);

            InternalPrintTicket deltaTicket  = (deltaPrintTicket != null) ? new InternalPrintTicket(deltaPrintTicket) : null;
            DevMode             deltaDevMode = defaultDevMode.Clone();

            PrintTicketToDevMode(deltaDevMode, deltaTicket, scope, supportedFields);

            // DevMode Merge - Copy fields set in baseDevMode but not set in deltaDevMode
            deltaDevMode.Copy(baseDevMode, baseDevMode.Fields & (~deltaDevMode.Fields));

            conflictStatus = Validate(deltaDevMode) ? ConflictStatus.NoConflict : ConflictStatus.ConflictResolved;

            InternalPrintTicket validatedTicket = DevModeToPrintTicket(deltaDevMode, scope, supportedFields);

            return(validatedTicket.XmlStream);
        }
Exemple #2
0
 /// <summary>
 /// Constructor. It's internal so client won't be able to construct one.
 /// </summary>
 /// <param name="validatedPrintTicketStream">resulting PrintTicket stream of the validation</param>
 /// <param name="conflictStatus">conflict resolution result of PrintTicket validation</param>
 internal ValidationResult(MemoryStream validatedPrintTicketStream,
                           ConflictStatus conflictStatus)
 {
     _ptStream    = validatedPrintTicketStream;
     _status      = conflictStatus;
     _printTicket = null;
 }
Exemple #3
0
 /// <summary>
 /// Merges delta PrintTicket with base PrintTicket and then validates the merged PrintTicket.
 /// </summary>
 /// <param name="basePrintTicket">The MemoryStream that contains base XML PrintTicket.</param>
 /// <param name="deltaPrintTicket">The MemoryStream that contains delta XML PrintTicket.</param>
 /// <param name="scope">scope that delta PrintTicket and result PrintTicket will be limited to</param>
 /// <param name="conflictStatus">The returned conflict resolving status.</param>
 /// <returns>MemoryStream that contains validated and merged PrintTicket XML.</returns>
 public abstract MemoryStream MergeAndValidatePrintTicket(MemoryStream basePrintTicket,
                                                          MemoryStream deltaPrintTicket,
                                                          PrintTicketScope scope,
                                                          out ConflictStatus conflictStatus);
Exemple #4
0
        /// <summary>
        /// Merges delta PrintTicket with base PrintTicket and then validates the merged PrintTicket.
        /// </summary>
        /// <param name="basePrintTicket">The MemoryStream that contains base XML PrintTicket.</param>
        /// <param name="deltaPrintTicket">The MemoryStream that contains delta XML PrintTicket.</param>
        /// <param name="scope">scope that delta PrintTicket and result PrintTicket will be limited to</param>
        /// <param name="conflictStatus">The returned conflict resolving status.</param>
        /// <returns>MemoryStream that contains validated and merged PrintTicket XML.</returns>
        /// <exception cref="ObjectDisposedException">
        /// The PTProvider instance has already been disposed.
        /// </exception>
        /// <exception cref="ArgumentException">
        /// The base PrintTicket specified by <paramref name="basePrintTicket"/> is not well-formed,
        /// or delta PrintTicket specified by <paramref name="deltaPrintTicket"/> is not well-formed.
        /// </exception>
        /// <exception cref="PrintQueueException">
        /// The PTProvider instance failed to merge and validate the input PrintTicket(s).
        /// </exception>
        /// <exception cref="PrintingNotSupportedException">
        /// Printing components are not installed on the client
        /// </exception>
        public override MemoryStream MergeAndValidatePrintTicket(MemoryStream basePrintTicket,
                                                                 MemoryStream deltaPrintTicket,
                                                                 PrintTicketScope scope,
                                                                 out ConflictStatus conflictStatus)
        {
            VerifyAccess();

            conflictStatus = ConflictStatus.NoConflict;

            IStream validatedPrintTicketStream = CreateStreamOnHGlobal();

            try
            {
                IStream baseTicketStream = IStreamFromMemoryStream(basePrintTicket);
                try
                {
                    IStream deltaTicketStream = IStreamFromMemoryStream(deltaPrintTicket);
                    try
                    {
                        string errorMsg;
                        uint   hResult = UnsafeNativeMethods.PTMergeAndValidatePrintTicket(_providerHandle,
                                                                                           baseTicketStream,
                                                                                           deltaTicketStream,
                                                                                           (uint)scope,
                                                                                           validatedPrintTicketStream,
                                                                                           out errorMsg);

                        if (PTUtility.IsSuccessCode(hResult))
                        {
                            // convert the success hResult to an enum value
                            switch (hResult)
                            {
                            case (uint)NativeErrorCode.S_PT_CONFLICT_RESOLVED:
                            {
                                conflictStatus = ConflictStatus.ConflictResolved;
                                break;
                            }

                            case (uint)NativeErrorCode.S_PT_NO_CONFLICT:
                            {
                                conflictStatus = ConflictStatus.NoConflict;
                                break;
                            }

                            default:
                            {
                                throw new PrintQueueException((int)hResult,
                                                              "PrintConfig.Provider.MergeValidateFail",
                                                              _deviceName);
                            }
                            }

                            RewindIStream(validatedPrintTicketStream);

                            return(MemoryStreamFromIStream(validatedPrintTicketStream));
                        }

                        if ((hResult == (uint)NativeErrorCode.E_PRINTTICKET_FORMAT) ||
                            (hResult == (uint)NativeErrorCode.E_DELTA_PRINTTICKET_FORMAT))
                        {
                            throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
                                                                      "{0} {1} {2}",
                                                                      PrintSchemaTags.Framework.PrintTicketRoot,
                                                                      PTUtility.GetTextFromResource("FormatException.XMLNotWellFormed"),
                                                                      errorMsg),
                                                        (hResult == (uint)NativeErrorCode.E_PRINTTICKET_FORMAT) ? "basePrintTicket" : "deltaPrintTicket");
                        }
                        else
                        {
                            throw new PrintQueueException((int)hResult,
                                                          "PrintConfig.Provider.MergeValidateFail",
                                                          _deviceName,
                                                          errorMsg);
                        }
                    }
                    finally
                    {
                        DeleteIStream(ref deltaTicketStream);
                    }
                }
                finally
                {
                    DeleteIStream(ref baseTicketStream);
                }
            }
            finally
            {
                DeleteIStream(ref validatedPrintTicketStream);
            }
        }
Exemple #5
0
 private void SetConflictStatus(string filename, ConflictStatus status)
 {
     Elems[filename].ConflictStatus = status;
 }