Is it possible to combine two PrintDocuments or...

[trint]

add them into one PrintDocument:
PrintDocument pd1 = new PrintDocument() ;
PrintDocument pd2 = new PrintDocument() ;

PrintDocument pdCombined = new PrintDocument() ;
pdCombined = pd1 + pd2;
pdCombined.Prin t();
Thanks,
Trint

[Bruce Wood]

What is your larger problem? You can't do this directly as you
described, but a PrintDocument object doesn't actually contain the
information to print. It relies on some outside object in your
application responding to its PrintPage events and drawing each page as
needed.

Where are your two PrintDocuments pd1 and pd2 coming from? For example,
if they are two input streams from two files, it should be a simple
matter to make a "combined stream" that reads from one and then from
the other, and feed that to your printing class.

In other words, I know of know way to combine two documents into one
after they've been "made into" PrintDocuments, but you should be able
to do it before, and create only one PrintDocument. Of course, that all
depends upon where the actual page rendering is taking place....
So, what are you trying to do, at a higher level?

[Trint Smith]

Bruce,
I am trying to do this:
Set my copies value to 3
start the first copy with a paper source (tray) as 4
when first copy is rendered, set paper source for
second copy to come from paper source 5.
When second copy is rendered, set paper source to come from 6 and that
is all. So that when printer actually begins the printjob it has been
sent, it prints three copies; one copy from each of the selected paper
trays (since we need a white paper copy, a yellow one and a pink one).
Here is my code so far:
class PrintReporttoLa serjet: Form1
{
PrintDocument pd = new PrintDocument() ;
// PrintReporttoLa serjet NeWrs = new PrintReporttoLa serjet();

// Form1 Form1Form = new Form1();
// Form1Form.Repor tingService rs = new ReportingServic e();
private byte[][] m_renderedRepor t;
private Graphics.Enumer ateMetafileProc m_delegate = null;
private MemoryStream m_currentPageSt ream;
private Metafile m_metafile = null;
int m_numberOfPages ;
private int m_currentPrinti ngPage;
private int m_lastPrintingP age;

public PrintReporttoLa serjet()
{
// Create proxy object and authenticate
//Console.WriteLi ne("Authenticat ing to the Web service...");
rs = new ReportingServic e();
rs.Credentials = System.Net.Cred entialCache.Def aultCredentials ;
}

public byte[][] RenderReport(st ring reportPath)
{
// Private variables for rendering
string deviceInfo = null;
string format = "IMAGE";
Byte[] firstPage = null;
string encoding;
string mimeType;
Warning[] warnings = null;
ParameterValue[] reportHistoryPa rameters = null;
string[] streamIDs = null;
Byte[][] pages = null;
///mine
// Build device info based on the start page

deviceInfo =
String.Format(@ "<DeviceInf o>" +
"<OutputFormat> {0}</OutputFormat>" +
"<Toolbar>False </Toolbar>" +
"<PageHeight>55 .82cm</PageHeight>" +
"<PageWidth>40. 26cm</PageWidth></DeviceInfo>","e mf");

// Prepare report parameter.
ParameterValue[] parameters = new ParameterValue[1];
parameters[0] = new ParameterValue( );
parameters[0].Name = "InvoiceNumber" ;
parameters[0].Value = Class1.inVoiceN umber;
//parameters[0].Value = "5440517";
//Exectute the report and get page count.
try
{
// Renders the first page of the report and returns streamIDs for
// subsequent pages
//firstPage = rs.Render(
firstPage = rs.Render(
reportPath,
format,
null,
deviceInfo,
parameters,
null,
null,
out encoding,
out mimeType,
out reportHistoryPa rameters,
out warnings,
out streamIDs);

// The total number of pages of the report is 1 + the streamIDs
m_numberOfPages = streamIDs.Lengt h + 1;
pages = new Byte[m_numberOfPages][];

// The first page was already rendered
pages[0] = firstPage;

for (int pageIndex = 1; pageIndex < m_numberOfPages ; pageIndex++)
{
// Build device info based on start page
deviceInfo =
String.Format(@ "<DeviceInfo><O utputFormat>{0} </OutputFormat><S tar
tPage>{1}</StartPage></DeviceInfo>","e mf", pageIndex+1);

pages[pageIndex] = rs.Render(
reportPath,
format,
null,
deviceInfo,
parameters,
null,
null,
out encoding,
out mimeType,
out reportHistoryPa rameters,
out warnings,
out streamIDs);
}
}

catch (SoapException ex)
{
//Console.WriteLi ne(ex.Detail.In nerXml);
using (StreamWriter sw = new StreamWriter("T estFile.txt"))
{
sw.Write(ex.Det ail.InnerXml);
}

}
finally
{
//Console.WriteLi ne("Number of pages: {0}", pages.Length);
}

return pages;
}

public bool PrintReport(str ing printerName)
{
int PDcounter;

// for (PDcounter = 0; PDcounter <= 2; Class1.counter+ +)
// {
this.RenderedRe port = this.RenderRepo rt(@"/Report
PackingList1/Report1");
//D:\Inetpub\wwwr oot\PackingList \Report Project1\printt est
//Report/PackingList1/Report1
PrintReporttoLa serjet f1 = new PrintReporttoLa serjet();

try
{
// Wait for the report to completely render.
if(m_numberOfPa ges < 1)
return false;
PrinterSettings printerSettings = new PrinterSettings ();
printerSettings .MaximumPage = m_numberOfPages ;
printerSettings .MinimumPage = 1;
printerSettings .PrintRange = PrintRange.Some Pages;
printerSettings .FromPage = 1;
printerSettings .ToPage = m_numberOfPages ;
printerSettings .Copies = 3;
printerSettings .PrinterName = printerName;

pd.DefaultPageS ettings.PaperSo urce =
pd.PrinterSetti ngs.PaperSource s[comboBox1.Selec tedIndex = 4];

m_currentPrinti ngPage = 1;
m_lastPrintingP age = m_numberOfPages ;
pd.PrinterSetti ngs = printerSettings ;
// Print report
pd.PrintPage += new PrintPageEventH andler(this.pd_ PrintPage);

try
{
///Print from tray 2
///Print from tray 3
///Print from tray 4
// Set the paper source based upon the selection in the combo box.
// pd.DefaultPageS ettings.PaperSo urce =
// pd.PrinterSetti ngs.PaperSource s[comboBox1.Selec tedIndex =
Class1.counter];

int pCounter = 0;
// while (pd.Print())
// {
// pCounter++;
//
// if(printerSetti ngs.Copies == 2)
// {
// pd.DefaultPageS ettings.PaperSo urce =
// pd.PrinterSetti ngs.PaperSource s[comboBox1.Selec tedIndex = 5];
//
// }
// if(printerSetti ngs.Copies == 1)
// {
// pd.DefaultPageS ettings.PaperSo urce =
// pd.PrinterSetti ngs.PaperSource s[comboBox1.Selec tedIndex = 6];
//
// }
//
// if(pCounter == 6)
// break;
//
// }
pd.Print();
//Wmis.PStatus();
}
catch(Exception ee)
{
MessageBox.Show (ee.Message);
}
finally
{
// PrintDirect.Clo sePrinter(lhPri nter);
}

}

catch(Exception ex)
{
MessageBox.Show (ex.Message);
}
finally
{
// Clean up goes here.
}
// if(PDcounter == 2)
// break;
// }
return true;
}

private void pd_PrintPage(ob ject sender, PrintPageEventA rgs ev)
{
ev.HasMorePages = false;
if (m_currentPrint ingPage <= m_lastPrintingP age &&
MoveToPage(m_cu rrentPrintingPa ge))
{
// Draw the page
ReportDrawPage( ev.Graphics);
// If the next page is less than or equal to the last page,
// print another page.
if (++m_currentPri ntingPage <= m_lastPrintingP age)
ev.HasMorePages = true;
}
}

// Method to draw the current emf memory stream
private void ReportDrawPage( Graphics g)
{
if(null == m_currentPageSt ream || 0 == m_currentPageSt ream.Length ||
null ==m_metafile)
return;
lock(this)
{
// Set the metafile delegate.

int width = m_metafile.Widt h;
int height= m_metafile.Heig ht;
m_delegate = new Graphics.Enumer ateMetafileProc (MetafileCallba ck);
// Draw in the rectangle

Point[] points = new Point[3];
Point destPoint = new Point(0, 0);
Point destPoint1 = new Point(width, 0);
Point destPoint2 = new Point(0, height);

points[0]=destPoint;
points[1]=destPoint1;
points[2]=destPoint2;
g.EnumerateMeta file(m_metafile ,points, m_delegate);

//g.EnumerateMeta file(m_metafile ,destPoint , m_delegate);
// Clean up
m_delegate = null;
}
}

private bool MoveToPage(Int3 2 page)
{
// Check to make sure that the current page exists in
// the array list
if(null == this.RenderedRe port[m_currentPrinti ngPage-1])
return false;
// Set current page stream equal to the rendered page
m_currentPageSt ream = new
MemoryStream(th is.RenderedRepo rt[m_currentPrinti ngPage-1]);
// Set its postion to start.
m_currentPageSt ream.Position = 0;
// Initialize the metafile
if(null != m_metafile)
{
m_metafile.Disp ose();
m_metafile = null;
}
// Load the metafile image for this page
m_metafile = new Metafile((Strea m)m_currentPage Stream);
return true;
}

private bool MetafileCallbac k(
EmfPlusRecordTy pe recordType,
int flags,
int dataSize,
IntPtr data,
PlayRecordCallb ack callbackData)
{
byte[] dataArray = null;
// Dance around unmanaged code.
if (data != IntPtr.Zero)
{
// Copy the unmanaged record to a managed byte buffer
// that can be used by PlayRecord.
// dataArray = new byte[dataSize];
dataArray = new byte[dataSize];
Marshal.Copy(da ta, dataArray, 0, dataSize);
}
// play the record.
m_metafile.Play Record(recordTy pe, flags, dataSize, dataArray);

return true;
}

public byte[][] RenderedReport
{
get
{
return m_renderedRepor t;
}
set
{
m_renderedRepor t = value;
}
}
}

Thanks,
Trint

..Net programmer
tr***********@g mail.com

*** Sent via Developersdex http://www.developersdex.com ***
Don't just participate in USENET...get rewarded for it!

[Bruce Wood]

So far as I know you can't do it that way.

Each print job (PrintDocument) is an object that specifies where its
paper is being fed from, whether it is using duplex, stuff like that.
One job has one set of attributes.

When you send three copies to a printer, the PC doesn't send the job
three times, or monitor the progress of the job. It sends the job once
and asks the printer to make three copies. (This applies to most modern
/ laser printers. Older printers without sophisticated software may
work differently. Regardless, the drivers are all designed so that your
software neither knows nor cares how the copies are being made.)

If your printer is on a print server then the job may print, and the
copies may be created, long after your application terminates.

One way to do what you want is to create three separate print jobs: one
feeding from paper source 4, one from paper source 5, and one from
paper source 6. Unfortunately, this creates three separate print jobs,
which aren't guaranteed to print in sequence, and won't interleave your
coloured pages, which is probably what you want. (You probably want the
first page white, yellow, pink, then the second page white, yellow,
pink, etc.)

To do the job up nicely, what you need to do is change pd_PrintPage.

First, you need a counter for pd_PrintPage, so that instead of
incrementing m_currentPrinti ngPage every time, you increment the
counter up to 3, then increment m_currentPrinti ngPage. So, in effect
calls to pd_PrintPage look like this:

pd_PrintPage: m_currentPrinti ngPage 1, copy 1
pd_PrintPage: m_currentPrinti ngPage 1, copy 2
pd_PrintPage: m_currentPrinti ngPage 1, copy 3
pd_PrintPage: m_currentPrinti ngPage 2, copy 1
pd_PrintPage: m_currentPrinti ngPage 2, copy 1
pd_PrintPage: m_currentPrinti ngPage 2, copy 1
etc.

So, now you have pd_PrintPage being called once for each copy of each
page. (Of course, you can get rid of your setting
printerSettings .Copies = 3, because you're now making the copies
"manually" inside pd_PrintPage.)

Now, you'll notice that pd_PrintPage receives a PrintPageEventA r*gs
class. One of the members of this class is PageSettings, and inside
there you'll find PaperSource. Inside pd_PrintPage just do this:

switch (m_copy)
{
case 1:
ev.PageSettings .PaperSource = ... ;
break;
case 2:
ev.PageSettings .PaperSource = ... ;
break;
case 3:
ev.PageSettings .PaperSource = ... ;
break;
default:
break;
}

Now you set the paper source to a different tray for each copy of each
page.

[Trint Smith]

Bruce,
I will try this immediately and get right back to you...you are very
helpful.
Thanks,
Trint

.Net programmer
tr***********@g mail.com

*** Sent via Developersdex http://www.developersdex.com ***
Don't just participate in USENET...get rewarded for it!

[Bruce Wood]

Oh, crap. My little example should have read:

pd_PrintPage: m_currentPrinti ngPage 1, copy 1
pd_PrintPage: m_currentPrinti ngPage 1, copy 2
pd_PrintPage: m_currentPrinti ngPage 1, copy 3
pd_PrintPage: m_currentPrinti ngPage 2, copy 1
pd_PrintPage: m_currentPrinti ngPage 2, copy 2
pd_PrintPage: m_currentPrinti ngPage 2, copy 3
etc.

That's what I get for using cut and paste.... :)

[Bruce Wood]

Thank you.

Trint, I'm going to give you a nudge as well: you have the same problem
being discussed in several threads here. Rather than posting your
problem over and over again in a new thread each time, please stick to
one thread. It makes things easier for all concerned, and makes it more
likely that you'll get quality responses.

Even if you post your problem and the answers you get back indicate
that nobody understood, reply to the original thread and add more
information, or rephrase the question. That way we can all see the
history and you don't have two different people trying to solve the
same problem without knowing about it, the way we have now.

Most newsreaders show threads in order of the last response to the
thread, most recent first, so if you reply to an old thread most people
will see the entire thread move to the top of their new list. There is
nothing to be gained by starting a new thread, unless, of course, you
have a totally different problem to discuss. :)

[Bruce Wood]

By the way, remember to check with the users (if you can) to see what
they're going to do with the copies.

If all they do is immediately separate them and send the white copy
here, and the yellow copy there, and the pink copy over there, then
just do three print jobs, since they don't need to be interleaved.

Can't count the number of times that I've made a Herculean effort to
get something like this to work "just right" only to discover that the
first thing my users do is some manual task that undoes all of my
tricky programming, and that both they and I would have been happer if
I'd just done it the drop-dead easy way. When I tell them that I can do
it the cheap and easy way (although I don't tell them that it's cheap
and easy), the response I often get is, "Oh, that would be fantastic...
you mean you can _do_ that?" :)

[Trint Smith]

Bruce,
I need a copy from tray 1 (white),
tray 2 (yellow),
and tray 3 (pink).
right before the print command I set the papersource to tray 1:
Class1.trayCoun t = 1;
pd.DefaultPageS ettings.PaperSo urce =
pd.PrinterSetti ngs.PaperSource s[comboBox1.Selec tedIndex =
Class1.trayCoun t]; Class1.trayCoun t = 4;
pd.Print();
I need a place that hits once for every copy...plus, I don't understand
where to put the code you gave me, other than in the:
private void pd_PrintPage(ob ject sender, PrintPageEventA rgs ev)
If I can get this one thing today, I will have solved a two week old
problem.
Thanks,
Trint
..Net programmer
tr***********@g mail.com

*** Sent via Developersdex http://www.developersdex.com ***
Don't just participate in USENET...get rewarded for it!

[Bruce Wood]

OK... you have to remember the following distinction.

The settings you make just before you call pd.Print() are _defaults_
for the _entire print job_. These defaults apply to every page for
which you do not specify explicit settings for _that page_.

However, every call into pd_PrintPage(ob ject sender, PrintPageEventA rgs
*ev) gives you the chance to change those settings _for that single
page_ that you're rendering during that call to pd_PrintPage().

In your case, you don't really care about the settings you make before
you call pd_PrintPage. They would come into play only if someone bumped
the number of copies from 3 to 4 and forgot to modify the code in
pd_PrintPage to compensate. Don't worry about that: the point is that
the settings you make before you call pd.Print() don't matter because
you'll be overriding them all anyway inside each call to
pd_PrintPage().

Yes, the code you need to change is inside pd_PrintPage() (other than
getting rid of the Copies=3 that you set before you called pd.Print()).
If you want to attack this problem in bite-sized chunks, do the
following:

1. Get rid of the .Copies=3 before you call pd.Print(). Run your
program. It should produce only one copy.
2. Add a new variable, this.m_copy, an integer. Initialize it to 1 just
before you call pd.Print(). Now, change pd_PrintPage() to do this:

// If this is the last copy then move to the next page
if (this.m_copy < 3)
{
this.m_copy += 1;
}
else
{
this.m_copy = 1;

// If the next page is less than or equal to the last p*age,
// print another page.
if (++m_currentPri ntingPage <= m_lastPrintingP age)
ev.HasMorePages = true;
}

Now run your program again. You should get three copies, as before,
collated: the first page three times, the second page three times, the
third page three times, etc.

3. Now the only thing to do is to change the page setting for each copy
so that it feeds froma different paper source. Add the switch statement
I showed you to the beginning of pd_PrintPage:

private void pd_PrintPage(ob ject sender, PrintPageEventA r*gs ev)
{
switch (m_copy)
{
case 1:
ev.PageSettings .PaperSource = ... ;
break;
case 2:
ev.PageSettings .PaperSource = ... ;
break;
case 3:
ev.PageSettings .PaperSource = ... ;
break;
default:
// This case will use the default PaperSource that you set
// before pd.Print(), but of course, this should never
happen....
break;
}
....
}

Into each case, substitute what you want the paper source to be for
that copy.

Run your program again. You should get three copies, one on each colour
paper, collated.

OK, so why does this work?

The PrintDocument doesn't really know how many pages there are to
print, or how pages get printed. It just blindly calls pd_PrintPage
over and over until pd_PrintPage says, "nothing more to print". What
page gets printed when, and how many times, is a problem for
pd_PrintPage to solve.

For example, you had to put special code into pd_PrintPage to handle
the situation in which the user asks to start at, say, page 6.
PrintDocument doesn't know how to do this. It just calls pd_PrintPage
the first time and in effect says, "Hey, you print the first page...
whatever page that is. It's no my problem to find the first page to
print... that's your problem."

Similarly, PrintDocument doesn't know or care whether pd_PrintPage is
going to advance to the next page image on each call. If pd_PrintPage
had a bug in it, it might print the same page over and over and
PrintDocument would just keep calling it forever.

In the same light, PrintDocument doesn't know that our new pd_PrintPage
is going to print the same page three times and then move on to the
next page. It just keeps calling until HasMorePages comes back false.
So, we "trick" it: on the first copy, we print the page and then we
_don't increment the page counter_ but increment the copy counter
instead. Then, next time PrintDocument calls pd_PrintPage, it will
print the _same page again_, but PrintDocument doesn't know that or
care. That's our problem to keep track of that. On the third call, once
again, we'll print the _same page_, but this time, knowing that it's
the third copy (because m_copy is 3), we'll reset m_copy to 1 and bump
the page counter up by _one_.

Then, on the next call, we'll print copy 1 of the _next page_, and on
it goes.

For _every copy of every page_ that pd_PrintPage prints (one copy of
one page on each call), it chooses which paper source _that page_
should print on by using the PrintPageEventA rgs.

The PrintPageEventA rgs.PageSetting s class has all of the settings
copied from those original settings you made before you called
pd.Print(). However, pd_PrintPage can change those settings _for the
single copy of the single page that it's rendering_. The next time it's
called the PageSettings are back to their defaults (as you set them
before calling pd.Print()) again. That's OK, because we override the
PaperSource for each copy of each page anyway.

Make sense?