The Deep End

Using Gmail with Thunderbird

2006-02-28T13:23:00.000-08:00

Thought this was kind of cool--using your gmail account with Thunderbird.

RSS Feeds in Thunderbird

2006-02-19T11:25:00.000-08:00

Mike McKay is writing an extension that will handle a feed and add it to the "rss feed list if it doesn't already exist."

I'm not much help because I know nothing about how thunderbird does rss feeds; does anyone know of any rss components or any extensions that would be similar enough to pick apart and examine?

DOM Inspector for 1.5??

2006-02-19T11:20:00.000-08:00

The DOM Inspector was great and I actually got it to work with Thunderbird. Unfortunately, it doesn't work anymore with 1.5. I tried just changing the maxVersion in the rdf file, but that didn't seem to work.

Is anyone working on this?? I was thinking I'd try and get it to work, but I don't even know where to begin.

2-28-06: uh...I posted a comment with a DOM Inspector for Thunderbird, but the link didn't come out right. Haven't tried it yet, but I'm going to; you should check it out, too!

Using Reloadchromezilla with Firefox/Thunderbird 1.5

2006-01-03T13:04:00.000-08:00

With whatever 1.5, you won't need to edit chrome.rdf! All you need to do is install Reloadchromezilla, install your extension, and reload the chrome as often as you would like! You will have to make one simple edit to a "chrome.manifest" file, as explained later.

As noted in this mozillazine entry, you could just restart firefox/thunderbird and see the changes you made in your extension. Reloadchromezilla is useful because instead of restarting, you can just click the button. This works because "reloading the chrome" will cause mozilla to update the changes you made to your extension. For more information on how Reloadchromezila works, see this previous post.

Read this mozillazine entry for how to package and install your extension, but the installation method below worked for me:

1. package your extension into an
.xpi, and drag into the extensions folder in your profile directory. This is usually located in C:\documents and settings\(your user name)\Application Data\Mozilla\Firefox or Application Data\Thunderbird

2. restart Firefox/thunderbird. On the restart, your extension will install.

3. once installed, to edit your files, extract your .jar file. This will reveal your .js and .xul files

4. To get the program to use these files instead of the .jar, you'll have to edit your chrome.manifest file. All you have to do is replace jar:chrome/(your extension).jar!/ with chrome/

you're replacing the jar stuff with "chrome" because the files will be in the chrome folder.

5. start developing! Use the Reloadchromezilla button or highly customizable context menu!

Mozilla Thunderbird: Creating Folders

2005-12-06T14:07:00.000-08:00

I don't remember if this was a previous post or not, but...

just get to your folder (see Navigating Folders)

this will be an nsIMsgFolder.

Use nsIMsgFolder.createSubfolder(folder_name,msgWindow);
As may be inferred, this will create the subfolder, but you have to update the parent folder to get it to show up in the Folder Pane.

parentFolder.updateFolder(msgWindow);

If you want to learn more about nsIMsgFolder, go to the XulPlanet article.

Updating Extensions to 1.5; Changes and Problems

2005-12-06T13:02:00.000-08:00

While frantically trying to understand how I'm going to make my extension compatibile with thunderbird 1.5 beta, I came across this.
The most important change that I see is the chrome.manifest file, which...replaces contents.rdf?

Anyway, it was useful to me to restructure my files as it's shown in the mozillazine article--you'll need to change the references to your .dtd files and .css files because the locations will be different. This may sound redundant or insane, but be sure those locations are correct! I had a lot of problems because I put chrome://thunderbirdtemplates/locale/en-US/overlay.dtd in the .xul instead of chrome://thunderbirdtemplates/locale/overlay.dtd

Good luck updating!

Updating Extensions for 1.5..."New" Extension Manager??

2005-11-22T13:16:00.000-08:00

Well, I've been having a lot of problems getting my extension to work with Thunderbird 1.5--this probably applies to the beta of Firefox, as well.

Although this won't cause errors when you try to install, your .xpi file is going to need these changes:

1) chrome.manifest file. This replaces contents.rdf--you don't need contents.rdf files in subfolders now, either. A good place to go is the Mozillazine article. Look at the file hierarchy for how to set up your .xpi.

Ok, not that bad. But what the heck is the "New Extension Manager"?? The Mozillazine article made this really confusing for me.

So go here.

File I/O in Mozilla

2005-10-30T18:08:00.000-08:00

For anyone interested in how File i/o works for Mozilla, check out the linked mozillazine article

Populating the Messagepane in Thunderbird??

2005-08-23T08:02:00.000-07:00

You know, the message preview pane--how does that get populated with the body of whatever selected message?? How do you get the body of a message in general? Setting up a stream and then reading the body out of the stream won't work for IMAP messages, because you have to download them first. How would one go about accomplishing that?

New Version!! Reloadchromezilla 0.0.6

2005-08-22T06:42:00.000-07:00

The New Version of Reloadchromezilla now works for firefox!

Aghhh So Complicated

2005-08-04T07:54:00.000-07:00

An interesting blog which might help with firefox and thunderbird development woes is David Huynh's blog. Maybe. I guess. All the posts look ridiculously complicated to me, but it seems like it's making sense to at least some people.

Alejandro Torrado debugs Reloadchromezilla

2005-08-03T10:45:00.000-07:00

Thanks Alejandro Torrado for finding an error in the new version of Reloadchromezilla (0.0.6) It's fixed now and the new version should show up on Mozilla Update any minute.

Xul: Creating toolbar buttons

2005-07-29T07:45:00.000-07:00

Mozillazine has a great article on creating toolbar buttons. One thing they sort of go into is toolbar palettes -- here are the toolbar palettes I've run across:

MailToolbarPalette: the toolbar in Thunderbird's main window

MsgComposeToolbarPalette: the toolbar for a Thunderbird compose window

AddressBookToolbarPalette: the toolbar for the address book toolbar palette, but if you're trying to write an overlay for the address book, you'll need to modify your contents.rdf file to add an overlay for the address book .xul file.

Arrays in Javascript

2005-07-26T08:55:00.000-07:00

Arrays in Javascript are awesome. Just look at all the things you can do with them:

you can pop,
you can push,
you can remove,
you can splice,
you can unshift (which adds new elements to the front and returns the length)
you can sort
you can reverse the entire array

you can define it like new Array("this", "this", "this", "this")
or like = ["jaa","whaa","gaaa"]

they're beautiful

about:Config Extension

2005-07-26T07:00:00.000-07:00

In previous Reloadchromezilla-related posts the process to add the nglayout.debug.disable_xul_cache preference is a little laborious -- it turns out that you can just download the about:config extension for Thunderbird! You can read more about the about:config extension here. It's a great extension, and from my experience, worked a lot better than the preferential extension (which consistently crashed Thunderbird while building a tree of preferences)

How do you download messages from an IMAP folder??

2005-07-14T07:16:00.000-07:00

How do you download messages from a folder on an IMAP server?? Specifically, with an XPCOM component of some kind...

using folder.DownloadMessagesForOffline(msgHdrArray,msgWindow); doesn't work.

nsIImapService has a downloadMessagesForOffline(),but the parameters are really confusing-- a "char *" of messageIds?? Does that mean that I'm supposed to do something like var messageIds = id1 + "," +id2?? How would I even get a messageId if none of the messages have been downloaded yet (the getMessages function returns an empty nsISimpleEnumerator)

What the heck?

I wrote an extension!!

2005-07-11T13:05:00.000-07:00

It's called Reloadchromezilla (yep) and it can be downloaded here at Mozilla Update.

It adds a "Reload Chrome" option to the context menu and a toolbar button.

As far as version 0.0.3 is concerned, you'll still need to set things up before Reloadchromezilla will work (see previous posts), but eventually Reloadchromezilla may do this on its own.

PART TWO: No More Restarts to Thunderbird Ext...

2005-07-06T09:20:00.000-07:00

This post deals with some features of the new Reloadchromezilla extension and how to set up your development environment for Reloadchromezilla to work. Part One deals with how Reloadchromezilla actually works.

You'll have to configure a lot of stuff in Thunderbird:

(1) go to the Mozillazine Knowledgebase entry, "Setting Up the Extension Development Environment" Everything here is pretty straightforward--basically, there are just a few handy options which I don't actually use.

(2) Disable The "XUL Cache" This is another Knowledgebase entry. Disabling the XUL cache is a must for the "Reload Chrome" feature to work. Basically, you need to find your extension in your profile directory, unpack the .jar file, and remove references to the jar file in the chrome.rdf and install.rdf files--read the article.

As the article states, you will also have to set a preference in your user.js, which Thunderbird does not automatically create. So you might need to:

(3) Create a user.js file: First, get to your profile -- for example, c:\documents and settings\{user}\Application Data\Thunderbird\Profiles\{your profile--if there's more than one, explore around to find the one that's yours}
Next, create a file called user.js with something like Notepad, and add,

user_pref("nglayout.debug.disable_xul_cache", true);

You've just created a user.js file and disabled the XUL cache!

However, as Disable The "XUL Cache" further states, you'll also need to edit install.rdf and chrome.rdf. The article also goes on to state something about injecting Javascript, but I'm not sure how this would work if you have a large and complicated extension--I ignored it.

And you should be done! The files that you edit from now on should be the files in your profile's extensions folder--find your GUID, open that folder, open some files and extend away! Unfortunately, the Reloadchromezilla extension (which follows the procedure outlined in previous posts) will not update changes you make to your install.rdf file. I'm guessing that the reason for this is that because the install.rdf file is not in what would normally be your .jar, it is outside the chrome. If you want to change the install.rdf file, you'll need to reinstall your extenesion the normal way, with the "Extension Builder" option of the Extension Builder's Extension

Note: as the knowledgebase articles state, you'll need to unpack your .jar file in your extension directory (which is located in your profile directory)

PART ONE: No More Restarts for Installing Thunderbird Extensions

2005-07-05T13:09:00.000-07:00

What came of this post was theReloadchromezilla extension; if you're looking for how to set up Thunderbird to use Reloadchromezilla, see Part Two--Part One deals with how the extension actually works.

As I wandered the Internet for how to not have to package your .xpi, install, and restart thunderbird, I happened across Ted Mielczarek's Extension Developer's Extension. Apparently, this program works beautifully and effortlessly for Firefox, but unfortunately I develop for Thunderbird. Mr. Mielczarek seemed to be having a problem with getting this to work in Thunderbird, so I opened up the .xpi (hope you don't mind; thanks for the great extension) and poked around until I got it to work.

The feature of the Extension Developer's Extension that allows you to see your changes without restarting is the "Reload All Chrome" feature. The "Reload All Chrome" feature consists of getting an instance of a @mozilla.org/chrome/chrome-registry;1 component, like this:

var chromeRegistry = Components.classes["@mozilla.org/chrome/chrome-registry;1"]. getService(Components.interfaces.nsIXULChromeRegistry);

The nsIXulChromeRegistry interface is the one with the reloadChrome method.

Because the method's name is "reloadChrome," you would expect this to work. However, calling this will just mutate your Thunderbird window into a mass of deformity which is summarily unresponsive to doing whatever you normally do with Thunderbird.

I think the moral of this brief and ultimately fulfilling story is to never give up, even when confronted by the most insane difficulties. Basically, you just call reloadChrome() again!

here's the code:

function reloadTheChromeDammit(){ try { var chromeRegistry = Components.classes["@mozilla.org/chrome/chrome-registry;1"]. getService(Components.interfaces.nsIXULChromeRegistry); chromeRegistry.reloadChrome(); var params ={out: ""}; window.open("chrome://reloadchromezilla/content/pleasewaitdialog.xul", "_blank", "chrome,close,titlebar,modal,centerscreen"); } catch(e) { } }

The "dialog" pleasewaitdialog.xul is really just a window. The .xul file looks like this:

<page id="please-wait-dialog" title="Please Wait" xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" onload="pleaseWaitLoad();"> <description value="Please wait while whatever aweseome modifications you've made to your chrome are loaded"> <script src= "chrome://reloadchromezilla/content/reloadchromezillaoverlay.js"> </script> </description></page>

The function pleaseWaitLoad() looks like this:

function pleaseWaitLoad(){ try{ var dialog = document.getElementById("please-wait-dialog"); setTimeout(function(){try{ var chromeRegistry = Components.classes["@mozilla.org/chrome/chrome-registry;1"]. getService(Components.interfaces.nsIXULChromeRegistry); chromeRegistry.reloadChrome(); window.close(); }catch(e){alert(e)}},2000); }catch(e){ alert("in pleasewaitload "+e); } }

this is necessary because without setTimeout, Thunderbird executes the two reloadChrome() functions too quickly--apparently, you have to wait until Thunderbird has completely hosed itself from the first reloadChrome() before you can bring it back with another call to reloadChrome().

Hopefully this was useful to someone; an extension may follow.

Again, thank you Ted Mielczarek for being a lot better at developing Mozilla than I am!

JavaScript Guide

2005-07-01T07:48:00.000-07:00

Found a great link while searching for info on the throw statement in Javascript--if you need to clarify something about Javascript's syntax, go to the Core JavaScript Guide. And hey, you can even download it!

Javascript: Converting Strings to Integers

2005-06-07T12:10:00.000-07:00

Go here.

Thunderbird: DOMming Around

2005-06-07T06:19:00.000-07:00

First, get the DOM Inspector for Thunderbird. Because the DOM Inspector, apparently, was included in Thunderbird for a little while but discontinued, it's a little weird to install, but there are detailed instructions--basically, you just have to delete a few files. There may be a version 0.0.2, but I got 0.0.1 from here and I have no complaints.

After you get the DOM Inspector, everything will be great. Want to get the body of that message, but don't feel like downloading it? Headers starting to bore you? Well, just
get the selected message

var view = GetDBView(); var hdr = view.hdrForFirstSelectedMessage;

then get the Message Pane (that preview window at the bottom, if you have 3-pane Thunderbird)

var messagePane = document.getElementById("messagepane");

and then...get really complicated:

var msgPaneDocChildren = messagePane.contentDocument.childNodes; var ndHTML = msgPaneDocChildren.item(0); var ndHead = ndHTML.childNodes.item(0); var ndBODY = ndHTML.childNodes.item(2); var ndDIV = ndBODY.childNodes.item(1); var domBody = ""; //now find the a tags, if any try{ var htmlPre = ndDIV.childNodes.item(0); var htmlPreText = htmlPre.childNodes.item(0); domBody = htmlPreText.nodeValue; for(var i = 0; i < dombody =" domBody" dombody =" domBody+htmlPre.childNodes.item(i);" nddivtext =" ndDIV.childNodes.item(0);" dombody =" ndDivText.nodeValue;">

ok: messagePane itself is a browser object. You can find it via the DOM Inspector by:

(1) file --> Inspect A Window --> Inbox
(2) Search --> Find Nodes
(3) Search by Tag Name for browser

messagePane has an attribute called contentDocument which will show up in the DOM Inspector as #document (and purple).
Going deeper into the DOM Tree--or DOM Hell; whatever--the childNodes of messagePane.contentDocument will be a single Node whose nodeName (nodeName is a property) is "HTML." As you can see, this is where I got var ndHTML = msgPaneDocChildren.item(0); "Open this up"--ndHTML.childNodes--and you'll get three children this time with nodeNames "HEAD," "#text," and "BODY." As you'll see from the DOM Inspector, #text is basically an empty string. What is represented in the DOM Inspector as "#text" is really a nsIDOMText node. However, since the body of the message is a text node like this, to get the string out of a node that shows up #text in the DOM Inspector, use node.nodeValue.

Ok so anyways, if we're getting the body of the selected message, we want the child of ndHTML called "BODY."

var ndBODY = ndHTML.childNodes.item(2);

Now, child 1 is a text node, but child 2 is a "DIV" element. Open that (var ndDIV = ndBODY.childNodes.item(1);), and things get a little strange again:

You will either have (the easy case) a "#text" node which contains the body--nodeValue that and you're done!

The more difficult case is if you have, instead of a #text node, an HTML Pre Element. In the code above, this would be that large try/catch block. Use QueryInterface to see if the node really is an HTMLPreElement--if not, then it's probably a #text node.

If it is a PRE Element,

var htmlPre = ndDIV.childNodes.item(0); var htmlPreText = htmlPre.childNodes.item(0);

the childNodes of htmlPre will be, hopefully, some #text nodes and possibly, if there are any links in the email message, some A tags, which you will have to open up and get their #text nodes, depending on how many A tags there are. Basically, use the DOM Inspector to find out which cases you'll have to handle, and just get to the #text nodes. Once you've gotten to a text node, you're done--just use .nodeValue to get the text.

The code above should work. I think I've handled all the cases. The only thing I can think of is if there's another html element in the email message like strong or something--the best way is probably to recurse until you get all the #text nodes.

Hopefully, even if you weren't looking for another way to get the body of an email message, this post will still be useful because it provides a basis for getting anything you can see in Thunderbird--just find the right window, and explore around with the DOM Inspector until you have it.

Want to get the date of a selected message?

function elt_getDate(){ var dateBox = document.getElementById("collapseddateValue"); return dateBox.inputField.value; }

&c, &c.

Thunderbird: How to Open a Dialog Window

2005-06-06T06:28:00.000-07:00

window.openDialog( "chrome://editor/content/EdFormProps.xul", "_blank", "chrome,close,titlebar,modal"); window.content.focus();

Found this in line 2511 of ComposerCommands.js. Could be useful when designing some options menu for your particular extension.

If you were designing some kind of options window, you would replace EdFormProps.xul with your own .xul file.

Great Band: Doves

2005-06-06T06:14:00.000-07:00

Doves are great! They sound almost like Coldplay (which may or may not be a good thing), except weird like Pink Floyd and The Flaming Lips.

Thunderbird And Mozilla Development: Search the Mozilla Source!!

2005-06-01T07:54:00.000-07:00

Search the Mozilla source!! I have been looking for something like this for a really long time. More posts citing various important areas later!

Thunderbird Extensions Documentation: Wielding the nsIEnumerator

2005-05-31T10:10:00.000-07:00

This post deals with the two kinds of enumerators in Mozilla. nsISimpleEnumerator is really simple, and there's no reason to talk about that.

nsIEnumerator is really bizarre, and although this may seem obvious to everyone else, this might be helpful to anyone who's a little stuck.

Basically, nsIEnumerator runs happily until it crashes.

Here's some code that you can pretend is a while(friendlyAndNice.hasNext()) loop:

var keepGoing = 1; 
  
  blah
  
  try{
   nseSubFolders.first();
  }catch(e1){
   keepGoing = 0;
  }
  
  
  while(keepGoing == 1){
   thing = blah.currentItem();
  
  
   try{
    nseSubFolders.next();
   }catch(e2){
    keepGoing = 0;   
   }
}

Thunderbird Extensions Documentation: Going from Message Key to Message Uri

2005-05-31T06:51:00.000-07:00

A lot of functions that I've come across in Mozilla require something called a "message uri"-- like the nsIMessenger component's getMessageServiceFromUri. Since most of my other posts deal with something else called a "message key," here's how to convert between them:fdr.generateMessageURI(msgKey);

So you could write something like,

var fdr = hdr.folder; fdr.generateMessageURI(hdr.messageKey);

. I think. If not, you may have to Get To The Folder From An Account or Local Folders (see post).

Thunderbird Extensions: Adding Stuff to the Editor Tag

2005-05-19T12:39:00.000-07:00

This post describes how to add stuff to the message body textbox in a compose window. The message body textbox is really a XUL element called the editor tag. If you search around the mozilla source (line 692 of messengercompose.xul), you'll find

<editor type="content-primary" id="content-frame" src="about:blank" name="browser.message.body" flex="1">

Apparently, the editor tag is really, in Javascript, a nsIEditorBoxObject. The Mozilla Documentation has some highly informative information about this, although it didn't really help me.

What did help me was wandering helplessly around the Internet and XulPlanet until I found The Answer. Here it is:

var domndEditor = document.getElementById("content-frame"); var htmlEditor = domndEditor.getHTMLEditor(domndEditor.contentWindow); //htmlEditor is the same // thing as nsiEditor!!! //this means that the editor //is a bizarre mixture //of about a gazillion //interfaces. //there may be some better way to do this if(body.toUpperCase().indexOf("html")==-1){ htmlEditor = htmlEditor.QueryInterface(Components.interfaces.nsIPlaintextEditor); //this is so weird. htmlEditor, I command you to become an //nsIPlainTextEditor!!! //... //it worked! htmlEditor.insertText(body); } else htmlEditor.insertHTML(body); //body is whatever text you'd like to //insert into the editor tag (or "that textbox message body thing in a //compose window")

Thunderbird Extensions: A Better Way to Navigate Folders

2005-04-14T14:40:00.000-07:00

Previously, I introduced a way to navigate folders using nsIMsgDBView.
Unfortunately, this will only work when you have the right folders selected in the tree /navigator/thing on the left of thunderbird. Also, the tree must be fully expanded.

Because that's horrible, there's a different and better way.

var accountManager = Components.classes ["@mozilla.org/messenger/account-manager;1"] .getService( Components.interfaces.nsIMsgAccountManager); var fdrlocal = accountManager.localFoldersServer.rootFolder; var fdrfoo = fdrlocal.FindSubFolder("Foo");

This will work all the time.

accountManager is a spiffy Component which keeps track of your accounts--and their folders! localFoldersServer.rootFolder will get you the server for "Local Folders," and then the Local Folders folder itself. After that, because fdrlocal is a nsIMsgFolder , feel free to use any of the previously mentioned functions to navigate around. GetSubFolder(String folderName) and the rootFolder property were mentioned in the example and in previous posts, but looking at XulPlanet's documentation would be a good idea.

Java Apps: Events, Button-Clicks, and How to Make Your Program Work

2005-03-08T05:47:00.000-08:00

Although adding buttons is fun and looks cool, it's a whole lot better when you can click on them and have things actually happen.

When the user clicks on a button (or moves a mouse or presses a key) it's called an Event. The general terminology is that an event gets "fired" (when you click that button) and to "catch" the event, you'll need to do a lot of stuff.

Firstly, your program will have to implement the ActionListener interface--this means that you have to have an actionPerformed() method somewhere in the class that is your app. The parameter to actionPerformed is an ActionEvent which is basically the event that's just occurred.

If you just have one button, then the actionPerformed method is all you'll need. Just type in the code that you want "performed" when the event fires--like

System.out.println("I've just been pressed!");

However, there are a few more things that you have to do:

1. Don't forget to put implements ActionListener next to your class name, and import the package java.awt.event.*.
2. When you create a button that you want actionPerformed to trap the events for, write this:

JButton btn = new JButton("Click Me, I'm Fatal"); btn.addActionListener(this);

This makes sense because you want to be "listening" for an event, and because this (which is your class) implements ActionListener, it is an ActionListener. It's also where the actionPerformed method is; it's all tied together!

If you have more than one button that you want to handle events for, use addActionListener(this) as usual, but in the actionPerformed method you'll need to write something like:

public void actionPerformed(ActionEvent e){ String action = e.getActionCommand(); if(action.equals("Click Me, I'm Fatal")){ ... } else if(action.equals("I'm Another Button!")){ .... } }

getActionCommand() returns the name of the Component.

There are lots of other events other than ActionEvent--like KeyEvent or MouseEvent, but they're pretty easy to understand once you've gotten ActionEvent. You'll have to add KeyListeners, MouseListeners, etc. and implement the MouseListener/KeyListener interfaces, but there are Java Tutorials for that.

Swing Java Apps Tutorial

2005-03-03T05:24:00.000-08:00

Java applications (not Java applets, which are a lot different) begin with a JFrame--although the best place to begin is here, at the Java Tutorial. In the tutorial, they use threads, which may make the program safe but is also very confusing and not fun if you have to hard-code the entire thing anyways.

frame.pack() shrinks the app down to the size of the components--so you don't have a lot of extra space. setVisible(true) makes it visible...

The JFrame is the main window--this kind of makes sense because it's like a picture frame into which you add contents like...pictures. You do this using frame.getContentPane().add(your Component) You can read more about JFrame here.

After you've got a JFrame, you can add all sorts of things. Reading the Swing Tutorial would be a lot better than me putting up everything I know (which isn't a lot) but a few spiffy items to get started with are:

JTextField!
JButton!
JLabel!

Organizing Your App

To organize your gui (graphical user interface), if you're hard-coding everything, then you'll need to use JPanels. JPanels are like mini-frames in that they start out empty and you can add stuff (Components) like JTextFields and JButtons to them. This makes your app more organized in that you can have inputPanel, which contains all the input Components (like JTextFields and JButtons), and labelPanel which would be the labels that you'll place above the input Components.

Positioning Stuff

To do things like place one JPanel above another, you'll need to use a Layout Manager. A great Java Tutorial is located here. By default, every Container (like a JPanel, JFrame, or anything that has an add() method) uses FlowLayout, which, as stated in the Java Tutorial, basically just adds things in a row.

A lot of the other layouts are really confusing, so the main one that I use is BorderLayout. For how to use BorderLayout, refer to the Java Tutorial segment "How to Use BorderLayout".

Hope that helps!

Thunderbird Extensions: nsIMsgComposeParams and nsIMsgCompFields

2005-03-01T13:42:00.000-08:00

nsIMsgComposeParams specifies the formatting of the Compose window that is opened when you call

OpenComposeWindowWithParams(null, params); //params is a nsIMsgComposeParams

In addition to type and format, which are explained in other posts, the other field that I saw used was composeFields, which is a nsIMsgCompFields. nsIMsgCompFields is basically the headers of the new message, plus the body. Just use the self-explanatory properties.

Thunderbird Extensions: nsIMsgCompType and nsIMsgCompFormat

2005-03-01T13:10:00.000-08:00

I didn't include this in the post "How to Open a Compose Window" because I'm not 100% sure what these components do. I have played around with them some, so the theory is this:

nsIMsgCompType dictates which type of compose window is going to be opened. How exactly this will change the look of the message, I don't know.

nsIMsgCompFormat formats, I think, the text that will make up the body of your message. For example, if you use PlainText on text that has HTML in it, you'll get tags.

In Relation to Opening a Compose Window

The component nsIMsgComposeParams has type and format properties--use nsIMsgCompType and nsIMsgCompFormat.

Obviously, if you write

var params = Components.classes['@mozilla.org/messengercompose/composeparams;1']. createInstance(Components.interfaces.nsIMsgComposeParams); var msgComposeFormat = Components.interfaces.nsIMsgCompFormat; ... params.format = msgComposeFormat.PlainText;

and later set body to text that uses HTML, then you'll see tags.

Thunderbird Extensions: Navigating Folders

2005-02-24T14:45:00.000-08:00

Your Thunderbird extension may need, at some point, to find a folder, delete a folder, get the messages in a folder, or whatever. And here's how!

var view = GetDBView(); view.doCommand(nsMsgViewCommandType.expandAll); var fldrlocal = view.getFolderForViewIndex(0).rootFolder; var fldrtemplates = fldrlocal.FindSubFolder("Templates"); var subfdr = fldrtemplates.FindSubFolder("Inferior Subfolder");

First of all, GetDBView() wasn't defined somewhere else in my .js file; apparently it is defined somewhere in the Thunderbird source, because you can use it and it works. Again, thanks to the DictionarySearch extension, because I got some of this code from there.

A major limitation of this code is that it assumes the folder at "View Index 0" has a root folder!!!

The only reason that this wouldn't work is if you had selected "Local Folders" instead of an actual folder. Normally this isn't a problem because by default "Inbox" is selected.

Something that I don't understand is the correlation between the list of folders in the Folders pane and the "ViewIndex". From prior experimentation I know that if you select a folder and then call getURIForViewIndex(int) then the uri returned will be the message uri of the somethingth message of whatever folder you have selected.

My guess is that a "ViewIndex" actually refers to a message, and getURI gets the message Uri while getFolder gets the parent folder. However, this may not be the case and should not be assumed to be true. If anyone really does know what a ViewIndex is, please feel free to comment or email me.

Once you've actually found a folder, moving around gets pretty easy. nsIMsgFolder is the XPCOM model of a folder, and there are some useful and self-explanatory functions at XulPlanet!

Thunderbird Extensions: Opening a Compose Window

2005-02-24T14:19:00.000-08:00

Previous posts have made vague and mysterious allusions to "opening a compose window" and to clear that up, here's how:

There are actually a multitude of ways to open a compose window, but most of them will have nsIMsgComposeParams and nsIMsgComposeService.

The way I found it done was in the DictionarySearch extension (this is a little bit different from his version but not much):

function composeMessageWithText(subject,text,type,format){ var msgComposeType = Components.interfaces.nsIMsgCompType; var msgComposFormat = Components.interfaces.nsIMsgCompFormat; var msgComposeService = Components.classes['@mozilla.org/messengercompose;1'].getService(); msgComposeService = msgComposeService.QueryInterface(Components.interfaces.nsIMsgComposeService); gAccountManager = Components.classes['@mozilla.org/messenger/account-manager;1']. getService(Components.interfaces.nsIMsgAccountManager); var params = Components.classes['@mozilla.org/messengercompose/composeparams;1']. createInstance(Components.interfaces.nsIMsgComposeParams); if (params) { params.type = msgComposeType.Template; params.format = format; var composeFields = Components.classes['@mozilla.org/messengercompose/composefields;1']. createInstance(Components.interfaces.nsIMsgCompFields); if (composeFields) { composeFields.to = "foo@foo.net" text = trimAll(text); composeFields.body = text; composeFields.subject = subject; params.composeFields = composeFields; msgComposeService.OpenComposeWindowWithParams(null, params); } } }

The other ways are all through msgComposeService; for the nsIMsgWindow parameter, type msgWindow. This works because...msgWindow is always the right menu? At any rate, it always works. Which is nice, even if it is complicated.

Thunderbird Extensions: How to Get the Body of A Message

2005-02-24T13:34:00.000-08:00

The XPCOM component nsIMsgHdr is, as you would expect, the header of a message. Oddly there doesn't seem to be a component like "nsITheMsg" that includes the header--the header is, for all practical purposes, the message. This means that getting to the body of the message is really frustrating. So--to get the body:

First you'll need to create an nsIInputStream . Because the stream that you create will need to "contain" the message, the getOfflineFileStream method of nsIMsgFolder will return a relevant stream.

The parameters of getOfflineFileStream are (1) the message key, which is a property of the header (yourHdr.messageKey); and two so-called "out" parameters--which is basically the way that javascript returns more than one thing. All that you need to do with these to make Thunderbird happy is to initialize them as Objects and then just pass them in. Like so:

var offset = new Object(); var messageSize = new Object(); try{ is = fdr.getOfflineFileStream(hdr.messageKey,offset,messageSize); }catch(e){ alert("message: "+e.message); }

fdr is the folder. If you're having trouble getting to the right folder/any folder, see the subsequent post on navigating folders with XPCOM.
Then, because nsIInputStream is a "frozen interface" (I'm not entirely sure what a frozen interface is, so I'm not going to guess) you'll need to use a safe, friendly wrapper class called nsIScriptableInputStream.
This code will get you the body and headers of the message (in other words the entire message):

try{ var factory = Components.classes["@mozilla.org/scriptableinputstream;1"]; var sis = factory.createInstance(nsIScriptableInputStream); sis.init(is); bodyAndHdr = sis.read(hdr.messageSize-10); //the -10 gets rid of this really weird "From - Tue " thing // (which is an exact quote). The reason why it shows "From - Tue" is //that it's actually part of the next message's header, and in fact, //the stream contains all of the messages in the folder. //it's as yet unclear why hdr.messageSize should be off by 10, or why //the out parameter to is (which is also called messageSize) always //shows up as 0. }catch(e){ alert("message: "+e.message); }

Weirdly, offset (the out parameter "returned" from getOfflineFileStream) has the same value as hdr.messageSize. This may be a problem with the API, because offset and messageSize are entirely different things.

As a side note, if you want to do anything at all with offset, use offset.value because offset is an object.

The last part to successfully getting the body--which is really sort of optional--is to open the body in a compose window.

One easy way to separate the hdr from the body in bodyAndHdr is:

var hdrstr = bodyAndHdr.indexOf("\r\n\r\n"); //marks the end of the //headers body = bodyAndHdr.substring(hdrstr+1,body.length);

Thunderbird Development: Extensions Introduction

2005-02-22T22:46:00.000-08:00

Well, this is my first post of any kind ever! I'm an intern and working on a project which requires the development of extensions for Thunderbird, Mozilla's mail client (see above picture.) Because there's not a lot of documentation for Mozilla--although apparently there are people out there who actually understand how it works--I've had to piece together a lot of juicy informational tidbits which sort of make sense as a cohesive whole.

Mozilla extensions (Firefox or Thunderbird) are composed of two main parts -- the .xul file, and the .js file (javascript). XUL is the xml-based graphical part of Mozilla, and there are extensive tutorials at XulPlanet. XulPlanet mostly just explains how xul can be used for gui's outside of Mozilla (and not specifically for Mozilla) so the best way that I found for learning how xul works is to download an extension and dissect all the files--this way, you can learn Mozilla-specific things like the name of the toolbar you're inserting a button into. Because my extension requires a button, I downloaded Buttons! by Maximum Extension. A great tutorial that explains the basics of extensions can be found on Eric Hamiter's blog , and I'll try not to repeat anything that's stated there.

The javascript is by far the most confusing half of writing an extension. While functions inherent to javascript like alert() are easy, most of the things that you'll want an extension to do are accomplished using XPCOM. An in-depth explanation and tutorial of xpcom can be found here at Mozilla's site. After the basics of all this, the most important part of writing an extension is finding the components/interfaces that you want, and you'll do that at xulplanet. Because xulplanet lists the components, properties, methods, etc., but doesn't actually explain what they mean, I soon developed an unhealthy love-hate relationship with that site, but the complete lack of meaningful information will develop your sixth sense to the uncanny point where you don't even need documentation--although it is xulplanet, not xpcomplanet.

Mozilla's site does have some interfaces documented; the ones that I found that were relevant to my purposes were found here and a few others which will be probably be posted up later. Poking around here would probably be helpful.

That's it for the introduction--later posts will be a lot more specific to certain components and interfaces (the ones that I'm using and happen to understand).