Feng Yuan (袁峰) : Printing

XpsStat: A program for gathering statistics information of XPS documents

fyuan — Mon, 21 May 2007 08:02:00 GMT

In the Winhec presentation on XPS document performance optimization, a simple program XpsStat is introduced to analyze XPS documents.

Given an XPS document, XpsStat generates four or five tables in HTML format:

Container Summary Table: information about each type of parts in the document.
FixedPage / Remote Resource Dictionary Table: information about each fixed page / remote resource dictionary in the document.
Font Resource Table: information about each font resource in the document
Image Resource Table: information about each image resource in the document
Container Part Table (optional): information about each part in the document

The program has three command line options:

/x Generate report in XML format instead of the default HTML format
/a Generate the optional Container Part Table
/d Extract fonts to external files, unobfuscated.

The program is written using .Net 3.0 XPS related API and some direct parsing of ZIP container. It supports both interleaved and non-interleaved XPS files.

Here is the binary: http://blog.fengyuan.com/XpsStat.exe

Here is what the Container Summary Table the program will generate for XPS Specification 1.0 in XPS format:

Container Summary
Type	Count	Piece	Uncompressed			Compressed			Compression
			Size	Percent	Average	Size	Percent	Average
fixedpage+xml	453	453	116,521,006	96.74 %	257,220	5,912,474	75.13 %	13,051	94.93 %
package.relationships+xml	434	434	573,558	0.48 %	1,321	164,871	2.09 %	379	71.25 %
properties+xml	1	1	673	0.00 %	673	342	0.00 %	342	49.18 %
fixeddocument+xml	1	1	289,702	0.24 %	289,702	13,756	0.17 %	13,756	95.25 %
opentype	20	20	1,647,572	1.37 %	82,378	576,144	7.32 %	28,807	65.03 %
image	492	492	1,042,993	0.87 %	2,119	992,681	12.61 %	2,017	4.82 %
fixeddocumentsequence+xml	1	1	320	0.00 %	320	160	0.00 %	160	50.00 %
documentstructure+xml	1	1	179,194	0.15 %	179,194	13,154	0.17 %	13,154	92.66 %
/Documents/1/	1	1	0	0.00 %	0	0	0.00 %	0	NaN %
/[Content_Types].xml	1	1	1,023	0.00 %	1,023	331	0.00 %	331	67.64 %
/Documents/1/_rels/	1	1	0	0.00 %	0	0	0.00 %	0	NaN %
/Documents/1/Pages/	1	1	0	0.00 %	0	0	0.00 %	0	NaN %
/Resources/Images/	1	1	0	0.00 %	0	0	0.00 %	0	NaN %
/Documents/1/Pages/_rels/	1	1	0	0.00 %	0	0	0.00 %	0	NaN %
/Documents/1/Structure/	1	1	0	0.00 %	0	0	0.00 %	0	NaN %
ZIP Structure			195,978	0.16 %	195,978	195,978	2.49 %	195,978	0.00 %
Summary	1,410	1,410	120,452,019	100.00 %	85,426	7,869,891	100.00 %	5,581	93.47 %

XPS Performance

fyuan — Thu, 17 May 2007 01:08:00 GMT

There will be two XPS related sessions at Winhec 2007 tomorrow, focusing on Performance Optimization for XPS Document.

The techincal presentation (CLN-T371 ) will be at 8:30am to 9:30am in Room 502AB. Shortly after that (9:45 to 10:45), there will be a chalk talk (CLN-C372) in Room 409A on the same topic.

The focus of the talk will be on how to generate the better XPS so that XPS documents can be consumed efficiently. So we will go into great deails about how to measure XPS document for performance and ideas on how to generate better XPS. But we will cover XPS performance issues in general. So even if you're just consuming XPS documents, this presentation should still be very much relevant to you. The reason is that this presentation is written from the viewpoint of a XPS consumer.

I'm pretty sure that you will either learn something useful from the presentation and chalk talk, or you can teach the community something about XPS.

Optimization XPS document is just part of the story in the whole world of XPS performance. The rest of the story includes performance of XPS filter pipeline, the design and configuration of XPS filters, the performance of XPS rendering (either host based or in printer firmware).

Talking about performance and learning, Zoran (www.zoran.com) has an encouraging demo at Winhec showing that their host-based rendering engine is able to achive print-engine-limited printing speed (HP Color LaserJet 4700, 31 ppm), for normal office type text documents with some vector graphics and images.

One final note, I was told that people tend to need lots of coffee for morning session after evening party.

See you tomorrow.

XPS at Winhec 2007

fyuan — Wed, 16 May 2007 00:41:00 GMT

Today (May 15, 2007) is the first day of Winhec 2007.

If you're application developers, printer/scanner/multi-functional device vendors, you may be interested in the following XPS related sessions.

CLN-T370 XPSDrv: Best Practice using Print Verifier, May 15, 3:15pm-4:15pm 515B, Manski & Ashwin
CLN-C369 (Chalk Talk) Print Verifier and XPSDrv Driver Development, May 15, 4:30pm-5:30pm 409A, Erhan
CLN-T375 HP Photo: Implementation Guidelines, May 16 11:00am-noon, 408AB, Bill Crow
CLN-T371 Performance Optimization for XPS Documents, May 17, 8:30am-9:30am 502AB, Feng
CLN-C372 (Chalk Talk) XPS Document Optimization and Best Practice, May 17 9:45am-10:45am, 409A, Rod

In the self-paced hands-lab, there is a XPSDrv related lab.

The following exhibitors are showing their XPS related technologies:

Artifex Softaware Inc. www.artifex.com
Global Graphics Software Incorporated, www.globalgraphics.com
Pagemark Technology, Inc, www.pagemarktechnology.com
QualityLogic, www.qualitylogic.com
Software Imaging, http://softwareimaging.com
Zoran Corporation, www.zoran.com
Canon, XPS printing through host-based rendering, 16-bit per channel image support.
Autodesk, native generation of XPS.

We're here at Winhec, talk to us.

A Simple XPS Decoder in C++

fyuan — Sun, 22 Apr 2007 12:47:00 GMT

If you write programs in C#, Windows Presentation Foundation in .Net 3.0 provides quite nice API to write, generate and manipulate XPS documents. You can get the same feature if you work with managed C++ in .Net 3.0. Even if you work with .Net 2.0, you can get the basic ZIP stream decoding/encoding support.

But if you want to write code in unmamanged world, especially outside of the XPS filter pipeline, there is not enough sample code there. I'm going to write a simple XPS decoder in C++, based on the zlib compression library (http://www.zlib.net/zlib123-dll.zip).

#include <windows.h>

#include <stdio.h>

#include <tchar.h>

#include "MemFile.h"

#include "zip.h"

#include "zlib.h"

#pragma comment(lib, "zdll.lib")

HANDLE CreateDirFile(char * pName, DWORD len, HRESULT & hr);

class CXps : CMemoryMappedFile

{

const CEndCentralDir * m_pEndCentralDir;

const CCentralFileHeader * m_pFileHeader;

public:

HRESULT LoadXps(const wchar_t * pFileName);

HRESULT DecodePiece(const BYTE * pCur, DWORD compressedSize);

HRESULT ExtractAllStreams();

};

The code uses zlib.h and zdll.lib for decompression. It opens up an XPS container as a memory-mapped file, wrapped in the CXps class. The CXps class has a pointer to end central directory, and a pointer to the first central file header.

HRESULT CXps::LoadXps(const wchar_t * pFileName)

{

m_pEndCentralDir = NULL;

m_pFileHeader;

if (! Open(pFileName))

{

return E_INVALIDARG;

}

const BYTE * pCur = m_View + m_nFileSize - (sizeof(CEndCentralDir) - 1);

while (pCur > m_View)

{

DWORD signature = * (DWORD *) pCur;

if (signature == sig_EndCentralDir)

{

m_pEndCentralDir = (const CEndCentralDir *) pCur;

m_pFileHeader = (const CCentralFileHeader *) (m_View + m_pEndCentralDir->m_offsetCentralDic);

return S_OK;

}

pCur --;

}

return E_FAIL;

}

The LoadXps method opens up an XPS file and locates its end central directory by reading backward from the end of the ZIP file.

HRESULT CXps::ExtractAllStreams()

{

HRESULT hr = S_OK;

const CCentralFileHeader * pFile = m_pFileHeader;

for (int i = 0; SUCCEEDED(hr) && (i < m_pEndCentralDir->m_entryCentralDic); i ++)

{

hr = DecodePiece(m_View + pFile->m_offsetLocalHeader, pFile->m_compressedSize);

pFile = (const CCentralFileHeader *) (pFile->m_Data + pFile->m_nFileName + pFile->m_nExtraField + pFile->m_nFileComment);

}

return hr;

}

int XpsExtract(const wchar_t * pFileName)

{

CXps xpsFile;

HRESULT hr = xpsFile.LoadXps(pFileName);

if (SUCCEEDED(hr))

{

hr = xpsFile.ExtractAllStreams();

}

printf("\nhr = %x\n", hr);

return 0;

}

The ExtractAllStreams method tries to extract every pieces in the XPS container to an file on the disk by calling DecodePiece method. The main routine XpsExtract is responsible for calling the loading routine and the main extracting routine.

The most complicated routine here is DecodePiece:

HRESULT CXps::DecodePiece(const BYTE * pCur, DWORD compressedSize)

{

HRESULT hr = S_OK;

const CLocalFileHeader * pHeader = (const CLocalFileHeader *) pCur;

char * pName = new char[pHeader->m_nFileName + 1];

if (pName == NULL)

{

return E_OUTOFMEMORY;

}

memcpy(pName, pHeader->m_Data, pHeader->m_nFileName);

pName[pHeader->m_nFileName] = 0;

printf("\n%8d %8d %-60s", pHeader->m_uncompressedSize, compressedSize, pName);

HANDLE hFile = CreateDirFile(pName, pHeader->m_nFileName, hr);

delete pName;

if (FAILED(hr))

{

printf("\nUnable to open file\n");

return hr;

}

pCur = pHeader->m_Data + pHeader->m_nFileName + pHeader->m_nExtraField;

if (pHeader->m_compression != 0)

{

BYTE * pOutput = new BYTE[pHeader->m_uncompressedSize];

if (pOutput == NULL)

{

return E_OUTOFMEMORY;

}

z_stream stream;

memset(&stream, 0, sizeof(stream));

stream.avail_in = compressedSize;

stream.avail_out = pHeader->m_uncompressedSize;

stream.next_in = (Bytef *) pCur;

stream.next_out = pOutput;

int result = inflateInit2(& stream, -MAX_WBITS);

if (result == Z_OK)

{

result = inflate(& stream, Z_SYNC_FLUSH);

}

DWORD dwWritten;

WriteFile(hFile, pOutput, pHeader->m_uncompressedSize, & dwWritten, NULL);

delete [] pOutput;

}

else

{

DWORD dwWritten;

WriteFile(hFile, pCur, pHeader->m_uncompressedSize, & dwWritten, NULL);

}

CloseHandle(hFile);

return hr;

}

DecocePiece has two parameters: a pointer to local file header structure, and compressed size. Note the compressed size may not be stored in the local file header, so it's better to pass it in from the end of the container. From the header structure, we can get its name and call CreateDirFile to create a corresponding file on the disk, making sure the proper directory path is created. The ZLIB decompression routine inflate, together with its preparation routine inflateInit2 are called when the piece is actually compressed. The result uncompressed streams are then written to disk.

The structures not shown here can be easily created by following ZIP specification at http://www.pkware.com/documents/casestudies/APPNOTE.TXT. The CreateDirFile routine is a simple wrapper around CreateFile and CreateDirectory.

The program is implicitly linked with ZLIB1 ZDLL.

Convert XAML Flow Document to XPS with Style (multiple page, page size, header, margin)

fyuan — Sat, 10 Mar 2007 22:39:00 GMT

XPS is a fixed document format in which pages are pre-formated to a fixed page sixe. On the opposite of the spectrum, WPF provides flow document which can be paginated dynamically in XAML viewer. To bridge the two, WPF provides features to convert a flow document to fixed document in XPS format. Actually, you can convert any WPF Visual content to XPS.

While the default conversion is very easy to use, if you want more features, you need to write some code. This acticle shows how to convert WPF flow document to multiple page XPS with page size, margin, and header.

When a flow document is loaded in WPF, it returns an IDocumentPaginatorSource object. From it, you can get its DocumentPaginator object. When you're using XpsSerializationManager to convert a loaded flow document to XPS, it accepts a DocumentPaginator object. But the little know fact is that WPF allows you to wrap a new DocumentPaginator around a DocumentPaginator to control the conversion process.

Here is our DocumentPaginator wrapper class:

public class DocumentPaginatorWrapper : DocumentPaginator

{

Size m_PageSize;

Size m_Margin;

DocumentPaginator m_Paginator;

Typeface m_Typeface;

public DocumentPaginatorWrapper(DocumentPaginator paginator, Size pageSize, Size margin)

{

m_PageSize = pageSize;

m_Margin = margin;

m_Paginator = paginator;

m_Paginator.PageSize = new Size(m_PageSize.Width - margin.Width * 2,

m_PageSize.Height - margin.Height * 2);

}

Rect Move(Rect rect)

{

if (rect.IsEmpty)

{

return rect;

}

else

{

return new Rect(rect.Left + m_Margin.Width, rect.Top + m_Margin.Height,

rect.Width, rect.Height);

}

public override DocumentPage GetPage(int pageNumber)

{

DocumentPage page = m_Paginator.GetPage(pageNumber);

// Create a wrapper visual for transformation and add extras

ContainerVisual newpage = new ContainerVisual();

DrawingVisual title = new DrawingVisual();

using (DrawingContext ctx = title.RenderOpen())

{

if (m_Typeface == null)

{

m_Typeface = new Typeface("Times New Roman");

}

FormattedText text = new FormattedText("Page " + (pageNumber + 1),

System.Globalization.CultureInfo.CurrentCulture, FlowDirection.LeftToRight,

m_Typeface, 14, Brushes.Black);

ctx.DrawText(text, new Point(0, -96 / 4)); // 1/4 inch above page content

}

DrawingVisual background = new DrawingVisual();

using (DrawingContext ctx = background.RenderOpen())

{

ctx.DrawRectangle(new SolidColorBrush(Color.FromRgb(240, 240, 240)), null, page.ContentBox);

}

newpage.Children.Add(background); // Scale down page and center

ContainerVisual smallerPage = new ContainerVisual();

smallerPage.Children.Add(page.Visual);

smallerPage.Transform = new MatrixTransform(0.95, 0, 0, 0.95,

0.025 * page.ContentBox.Width, 0.025 * page.ContentBox.Height);

newpage.Children.Add(smallerPage);

newpage.Children.Add(title);

newpage.Transform = new TranslateTransform(m_Margin.Width, m_Margin.Height);

return new DocumentPage(newpage, m_PageSize, Move(page.BleedBox), Move(page.ContentBox));

}

public override bool IsPageCountValid

{

get

{

return m_Paginator.IsPageCountValid;

}

public override int PageCount

{

get

{

return m_Paginator.PageCount;

}

public override Size PageSize

{

get

{

return m_Paginator.PageSize;

}

set

{

m_Paginator.PageSize = value;

}

public override IDocumentPaginatorSource Source

{

get

{

return m_Paginator.Source;

}

The DocumentPaginatorWrapper constructor modifies the page size of the original paginator based on required page size and margin. The new GetPage method calls the original GetPage method to get a page, then adds a header Visual, a background Visual (just to show the original page), and then move the combined Visual by top left margin. To demonstrate that you can easily transform a Visual, the original page Visual is scaled down and centered within its original box.

Here is the code calling the wrapper class to load a flow XAML document and convert to an XPS document:

public static int SaveAsXps(string fileName)

{

object doc;

FileInfo fileInfo = new FileInfo(fileName);

using (FileStream file = fileInfo.OpenRead())

{

System.Windows.Markup.ParserContext context = new System.Windows.Markup.ParserContext();

context.BaseUri = new Uri(fileInfo.FullName, UriKind.Absolute);

doc = System.Windows.Markup.XamlReader.Load(file, context);

}

if (! (doc is IDocumentPaginatorSource))

{

Console.WriteLine("DocumentPaginatorSource expected");

return -1;

}

using (Package container = Package.Open(fileName + ".xps", FileMode.Create))

{

using (XpsDocument xpsDoc = new XpsDocument(container, CompressionOption.Maximum))

{

XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);

DocumentPaginator paginator = ((IDocumentPaginatorSource)doc).DocumentPaginator;

// 8 inch x 6 inch, with half inch margin

paginator = new DocumentPaginatorWrapper(paginator, new Size(768, 676), new Size(48, 48));

rsm.SaveAsXaml(paginator);

}

Console.WriteLine("{0} generated.", fileName + ".xps");

return 0;

}

The code above loads a flow XAML document and paginates it to 8 inch by 6 inch, with half inch margin.

Here is a sample output:

The gray background is added to illustrate margin, header, and original page. The original page is scaled down by 5% and centered in the gray box.

The sample XAML file is extracted from WPF Feature Montage sample (http://wpf.netfx3.com/files/folders/code_snippets/entry3752.aspx).

Printing documents to Microsoft XPS Document Writer without user interaction

fyuan — Sun, 25 Feb 2007 02:03:00 GMT

Now that the XPS storm has been started, people are generating XPS documents from all kinds of sources. Among different ways of XPS generation, the easily way is still through printing to the Microsoft XPS Document Writer (the MXDW printer driver).

If you're printing from your own applications, it's easy to specify MXDW as the printer driver and provide a file name for the XPS document to be saved to. But if you're using certain applications to print a documents, a print dialog box and a file save dialog box could pop up on screen, blocking attempts for fully automatic document conversion.

For different document types, you can check Windows registry to find the command to print it. For example, the command to print an HTML page is:

rundll32.exe mshtml.dll,PrintHTML "<document>" "<driver>" "<device>" "<port>"

So you should be able to print any webpage to any printing device, to any printer/file, fully automatically. But this creates a security risk, so it has since been blocked. User confirmation is needed to print an HTML page through MSHTML.DLL.

But if you're willing to write some code, automatic document printing is still possible. Here is one solution:

#include <windows.h>

#include <strsafe.h>

const wchar_t * Dialog_Class = L"#32770";

HRESULT PrintHTML(const wchar_t * pUri, const wchar_t * pFileName)

{

HRESULT hr;

STARTUPINFO si = { sizeof(si) };

PROCESS_INFORMATION pi;

wchar_t command[MAX_PATH];

hr = StringCchPrintf(command, _countof(command),

L"rundll32.exe mshtml.dll,PrintHTML \"%s\"", pUri);

if (FAILED(hr))

{

return hr;

}

if (CreateProcess(0, command, 0, 0, FALSE, 0, 0, 0, &si, &pi))

{

printf("\r\nStarting '%S'\r\n", command);

CloseHandle(pi.hProcess);

CloseHandle(pi.hThread);

}

DWORD size = _countof(command);

GetDefaultPrinter(command, & size);

printf(" Default printer: '%S'\r\n", command);

printf("\r\nWaiting for Print dialog box\r\n");

Sleep(5 * 1000);

// Find Print Dialog box

HWND hWnd = FindWindow(Dialog_Class, L"Print");

// Print button

HWND hChild = FindWindowEx(hWnd, NULL, NULL, L"&Print");

GetWindowText(hChild, command, _countof(command));

printf(" hwnd = %p %p('%S')\r\n", hWnd, hChild, command);

// Press Print button

SendMessage (hChild, WM_IME_KEYDOWN, 'P', 0);

printf("\r\nWaiting for File Save dialog box\r\n");

Sleep(5 * 1000);

// Find Save File Dialog Box

hWnd = FindWindow(Dialog_Class, L"Save the file as");

hChild = FindWindowEx(hWnd, NULL, L"ComboBoxEx32", NULL);

hChild = FindWindowEx(hChild, NULL, L"ComboBox", NULL);

hChild = FindWindowEx(hChild, NULL, L"Edit", NULL); // File name edit control

printf(" hwnd = %p %p\r\n", hWnd, hChild);

// Enter file name

SendMessage(hChild, WM_SETTEXT, NULL, (LPARAM) pFileName);

Sleep(1000);

// Find Save button

hChild = FindWindowEx(hWnd, NULL, NULL, L"&Save");

GetWindowText(hChild, command, _countof(command));

printf(" hwnd = %p %p('%S')\r\n", hWnd, hChild, command);

// Press Save button

SendMessage (hChild, WM_IME_KEYDOWN, 'S', 0);

printf("\r\nSaving to '%S'\r\n", pFileName);

return hr;

}

The code uses CreateProcess to call rundll32 with the right parameters to start the printing process. It then waits for a while for the Print dialog box to pop up and fakes a click on the Print button. After that, it waits for the File Save dialog box to enter a destination file name and click on the Save button.

Here is how this routine can be called:

PrintHTML(L"http://blogs.msdn.com/fyuan", L"c:\\fyuan.xps");

The code will generate enough logging information for you to see if things are working or not:

Starting 'rundll32.exe mshtml.dll,PrintHTML "http://blogs.msdn.com/fyuan"'

Default printer: 'Microsoft XPS Document Writer'

Waiting for Print dialog box

hwnd = 0021075C 002B0754('&Print')

Waiting for File Save dialog box

hwnd = 001E04A2 00260B72

hwnd = 001E04A2 002D0BA6('&Save')

Saving to 'c:\fyuan.xps'

Note:

1) The code assumes MXDW is already the default printer driver. If this is not the case, you may want to add code to make it so before the Print dialog box pops up; or add code to mimic selection of MXDW as the printer driver.

2) The code uses fixed length wait for the Print dialog box and File SaveAs dialog box to pop up. This is not a very stable solution or it could take too much time. You may want to add better robust and efficient solutions.

3) The code is clealy very sensitive to OS version, application version, and UI language. You may need to find a more generic solution and a more robust solution.