object oEndOfDoc = "\\endofdoc"; /* \endofdoc is a predefined bookmark */
 
Word.Application app = new Word.Application();
 
Word.Document doc = app.Documents.Add(
    ref oMissing, ref oMissing, ref oMissing, ref oMissing
);
 
Word.Range line1 = doc.Bookmarks.Item(ref oEndOfDoc).Range;
line1.Text = "First line!";
line1.InsertParagraphAfter();
 
Word.Range line2 = doc.Bookmarks.Item(ref oEndOfDoc).Range;
line2.Text = "Second line!";
line2.InsertParagraphAfter();
 
Word.Range r = doc.Bookmarks.Item(ref oEndOfDoc).Range;
r.Text = "Name\tAge\tLocation\nNigel\t44\tUK\nBill\t33\tUSA\nRuben\t86\tNicaragua\n";
 
object tab = Word.WdTableFieldSeparator.wdSeparateByTabs;
Word.Table t  = r.ConvertToTable(
    ref tab,
    ref oMissing, ref oMissing, ref oMissing, ref oMissing,
    ref oMissing, ref oMissing, ref oMissing, ref oMissing,
    ref oMissing, ref oMissing, ref oMissing, ref oMissing,
    ref oMissing, ref oMissing, ref oMissing
);

Looks pretty obvious, doesn’t it? But it took me a while to get there. The important difference is that instead of…

Word.Range r = doc.Range(ref oMissing, ref oMissing);

…I used:

Word.Range r = doc.Bookmarks.Item(ref oEndOfDoc).Range;

What I had been experiencing with the former was a document with only the final item (the table) being added. In fact, all items had been added, but at the same location in the document – so each item was being overwritten by each subsequent item. This seems obvious too, in retrospect, because I was supplying the missing value to the Range constructor’s start and end parameters, so the target range became “everything”.

I couldn’t see – and still can’t – how you’re supposed to identify a range in an empty document, but I was fortunate enough to discover endofdoc, a built-in bookmark signifying the, er, end of a document.

object oEndOfDoc = "\\endofdoc"; /* \endofdoc is a predefined bookmark */

My requirement was simply to add items to the document sequentially, so using this bookmark for the range of each item did the trick. I think that’s me done with Word Automation…

P.S. In trying to find a solution I toyed with a Word document template with predefined mail merge fields acting as placeholders for the items I wanted to add. It almost worked until I tried to replace a field with my table. Any ideas why this doesn’t work?

foreach (Word.Field myMergeField in doc.Fields)
{
    // ...
    myMergeField.Select();
    app.Selection.Range.Text = "Name\tAge\tLocation\nNigel\t44\tUK\nBill\t33\tUSA\nRuben\t86\tNicaragua\n";
    app.Selection.Range.ConvertToTable(
        ref tab,
        ref oMissing, ref oMissing, ref oMissing, ref oMissing,
        ref oMissing, ref oMissing, ref oMissing, ref oMissing,
        ref oMissing, ref oMissing, ref oMissing, ref oMissing,
        ref oMissing, ref oMissing, ref oMissing
    );
}

I’m not going to describe in full how you need to prepare your Visual Studio project. For that, read this. I wanted to utilise the ConvertToTable() method of the Word.Range object which allows us to create a table using a string delimited by tabs and newlines such as this:

The MSDN page Automating Word Tables for Data Insertion and Extraction had taken me so far, but not all the way, so here’s the useful (read: missing) code to bring it all together:

Word.Application app = new Word.Application();
 
Word.Document doc = app.Documents.Add(
    ref oMissing, ref oMissing, ref oMissing, ref oMissing
);
 
Word.Range r = doc.Range(ref oMissing, ref oMissing);
r.Text = "Name\tAge\tLocation\nNigel\t44\tUK\nBill\t33\tUSA\nRuben\t86\tNicaragua\n";
 
object tab = Word.WdTableFieldSeparator.wdSeparateByTabs;
Word.Table t  = r.ConvertToTable(
    ref tab,
    ref oMissing, ref oMissing, ref oMissing, ref oMissing,
    ref oMissing, ref oMissing, ref oMissing, ref oMissing,
    ref oMissing, ref oMissing, ref oMissing, ref oMissing,
    ref oMissing, ref oMissing, ref oMissing
);

Please leave a comment if you have any questions on this, or if I’ve done something heinous that is a crime against Word automation

Good luck!

EDIT: If you need to add more than one item to a blank Word document, you might want to take a look at my subsequent post.

This information wasn’t immediately obvious via Google so I thought I’d post it up in an attempt to make it more findable by other folks. I actually got the information from Eric True. Thanks Eric!

This URL is the kind of thing one encounters when working with Web Map Services:

It returns a geographic map image based upon the name/value pairs passed in the querystring. Google Charts work in a similar way:

To tackle such long URLs I’ve developed the boringly-named URL Editor.

Find it here: http://gingerbbm.com/urleditor

It’s a pretty simple JavaScript application (using Prototype and Scriptaculous) whose main purpose is to split the long querystring of a URL into its constituent name/value pairs in order to dramatically improve legibility. Paste a URL into the main box, click Split, and the name/value pairs appear below:

Once a URL has been split, any edits to the individual values are immediately applied to the main URL, and vice versa.

The Encode and Decode buttons attempt to encode/decode any relevant values that exist.

Click Open to open the URL in its current state in a new window/tab. And Reset resets the whole page.

Reordering of name/value pairs is achieved by dragging them, and you can add and delete them by clicking the relevant buttons.

Bugs

It wouldn’t be hard to trip the application up. The key to it all is the question mark character that denotes the start of a querystring. If you’re not interested in ever opening the URL you can simply start typing into the main box, e.g. “?a=1″, and the name/value pairs will appear.

Names

So, “URL Editor” is a fairly sober moniker, but it was the best of a bad bunch, and being a pretty good description of what it does I decided to go with it.

• U.R.[NOT HEL]L.
• URL Manager
• URL Splitter
• Querystring Dechunker
• Any ideas?

And Finally

I’ve tried it out in FF3, IE8, Safari 3 and Opera 9 on XP and it’s all good. It also appears to work in FF3 and Safari 3 on the Mac. Not tried it on Chrome yet, but I don’t expect any surprises. For me it’s been fairly robust, and a useful tool in my arsenal. I hope others find it useful.

Get it here:
http://gingerbbm.com/software/PathAndFilenameToClipboardSetup.msi

It adds itself to the context menu in Explorer and appears like so:

Disclaimer: Of course this software comes with absolutely no guarantees or warranties of any kind! It should work on Windows XP; I’ve not tried it on anything else. If you have any difficulties leave a comment and I might take a look…

You’ve got a piece of code that creates an image in your web page by passing a bunch of parameters in a GET string to some server-side process:

$('tile').src = 'http://img.com/generate.php?a=1&b=2&c=3';

But what do you do when the URL goes beyond the limit? Practically, for cross-browser solutions, the limit is around 2000 characters (thanks to IE), and I recently had to find a workaround when generating images via a WMS.

The Solution

When we’re dealing with HTML forms, if a GET isn’t big enough we have to use a POST. The difficulty in the scenario described above is that there’s no way to provide the POST variables when making the assignment to the image’s src attribute.

I thought about how to use an Ajax POST but even if image data could be streamed back to the browser in this way, there’s no mechanism for getting it into an HTML image.

And then I discovered the data URI scheme which allows us to assign a base64 representation of an image to an HTML image like so (where the ellipsis indicates the position of the base64 data string):

$('tile').src = 'data:image/gif;base64,...';

If I could issue a POST to the server to generate my image, I could convert that image into a base64 string to pass back to the browser, which I could then utilise in the data URI scheme syntax.

I discovered this method in this brilliant post where the same trick is used to for CSS and to reduce HTTP requests. And by reading that post I learned that we have to do it another way in IE. In IE we have to use MHTML and it involves a little more work on the server but we can still end up with this (where somestring indicates the position in mhtml.txt of the base64 data string):

$('tile').src = 'mhtml:http://img.com/mhtml.txt!somestring';

A proxy script on the server is required to pass the POST variables through to the image-generation program, and convert the resultant image into a base64 data string. Since the WMS I use is located on an external server I was already using Troy Wolf’s PHP proxy script (note that it requires class.php). Converting to base64 is a cinch in PHP:

$base64_encoded_image = base64_encode($response);

I simply added the code I needed to the end of Troy’s proxy script.

So, the flow of events is:

• Client issues an Ajax POST request to the proxy script.
• Proxy forwards the request to the image-generation program and converts the resultant image into a base64 data string.
  • For IE, the proxy saves the string to a file and returns the filename to the client.
  • For all other browsers, the proxy returns the string to the client.
• Client’s Ajax “on success” callback assigns the relevant string to the HTML image’s src attribute.

Anyway, here’s a demo page.
And here’s a zip containing all the necessary files.

A Few Considerations

The IE workaround involves creating a file on the server that contains the base64 representation of the generated image. The format of the file must be as follows in terms of line breaks, and in terms of the double quotes around the boundary parameter:

Content-Type: multipart/related; boundary="_ANY_SEPARATOR"

--_ANY_SEPARATOR
Content-Location:somestring
Content-Transfer-Encoding:base64

R0lGODlh...snip...AACgAACoAAC

The folder in which the MHTML files are generated obviously requires the appropriate privileges. If this method were used in a production environment an automated procedure would be required to delete periodically old MHTML files. IE8 is a great improvement over previous versions and actually supports the data URI scheme, so one day in the distant future all the MHTML workaround shenanigans will be unnecessary. But until then we’re stuck with having to write a file to the server every time – and if we’re doing that it might be preferable simply to write the image to the server and return its URL to the browser. At least it would mean no JavaScript browser-sniffing, and that’s no bad thing.

1. pull down the list of search engines
2. scan for the one I want
3. type and go

To reduce friction when searching in common places I have the following bookmarklets defined.

Google Maps

javascript:p=prompt('GMaps%20search:');if(p)%20{%20p=p.replace(/\./g,%20'/');window.location='http://maps.google.co.uk?q='+p.toLowerCase();}

Dictionary.com

javascript:void(location.href='http://dictionary.reference.com/browse/'+prompt('Dictionary.com%20search:',''))

Prototype API

javascript:p=prompt('Prototype%20API%20search:');if(p)%20{%20p=p.replace(/\./g,%20'/');window.location='http://prototypejs.org/api/'+p.toLowerCase();}

To use these JavaScript snippets, assign them to a bookmark in your browser. For ease of access, place the bookmark on the Bookmarks Toolbar. This reduces the workflow to:

1. click the bookmarklet
2. type and go

It’s not rocket science. A simple Google search reveals all sorts of much-more-advanced bookmarklets. As far as bookmarklets for straightfoward searching are concerned, any more than three or so would feel like too many to me, and I’d opt for the browser’s quick search bar.

Creating the DLL

I used Visual Studio 2005 for this but I’m sure 2003 or 2008 can be used in a similar way. The important step is to choose the appropriate project type. Do the following:

• File > New > Project
• Project type: Visual C++ > Win32
• Template: Win32 Console Application
• Give your project a name (I have used “rwnet64″ in this example)

When you click OK you should see the Win32 Application Wizard:

Click Next to configure the application settings. As shown here, ensure that the DLL radio button is selected:

Click Finish to see the generated code:

The highlighted block shows a default entry point for the DLL. This can be safely deleted.

At this point the project should compile and we’re ready to add some code.

The following is an example of a simple function. The important thing to note is the compiler directive __declspec(dllexport) which is required for extproc to load the DLL successfully.

extern "C" __declspec(dllexport) int addTen (int val)
{
    return val + 10;
}

The project should compile. Build the DLL as a Release build (a Debug build won’t work with extproc), then copy it over to your Oracle server’s BIN or LIB folder.

Preparing Oracle

I’m going to assume that your instance of Oracle is already configured to use extproc, i.e. that listener.ora and tnsnames.ora have been set up correctly. I might come back and explain how to do this later, but in the meantime just Google for it.

To call our DLL from a PL/SQL routine via extproc, we need:

1. an Oracle library
2. a PL/SQL routine

The Oracle library can be created like this at a SQL*Plus prompt:

> create or replace library rwnet64
  as 'e:\oracle\product\10.2.0\db_2\lib\rwnet64.dll;
 
Library created.

Note: If this fails because your user doesn’t have the necessary privileges, run the following from a SQL*Plus prompt connected as the system user (where myuser is, er, your user):

> grant create library to myuser;

With the Oracle library created, we now need some code! Here’s an example package body:

CREATE OR REPLACE package body dlltest_pkg AS
 
    FUNCTION addTen(num IN pls_integer)
    RETURN pls_integer
    AS external
    LANGUAGE c
    library rwnet64
    name "addTen"
    parameters (num INT, RETURN INT);
 
END dlltest_pkg;
/

Once you’ve created the package (and you’ll need to write the accompanying package header script) the DLL can now be tested from a SQL*Plus prompt with the following:

> select dlltest_pkg.addTen(5) from dual;
 
DLLTEST_PKG.ADDTEN(5)
---------------------
 15

And that proves it: calling a function in a Win32 DLL written in C++ from a function in an Oracle package via extproc.

If you got this far you are now at liberty to create useful functionality in your DLL. One thing to watch out for is the choice of datatypes between the DLL and PL/SQL. This table is a useful starting point for ironing out any issues.

Good luck!