First of all, open regedit32.exe from the search box in the start menu.

Then, navigate to this key:

[HKEY_USERS\S-1-5-21-xxxxxxxx-xxxxxxxx-xxxxxxxx-xxxx\Software\Microsoft\Windows NT\CurrentVersion\Windows Messaging Subsystem\Profiles\

This should be showing a list of the mail profiles you have on your machine:

Navigate slightly further down the tree this time, to the key labelled:

<Profile Name>\9375CFF0413111d3B88A00104B2A6676\

This is the key that stores a list of all the email accounts in your Outlook profile:

To transfer these accounts to a different profile, or a different machine, do the following:

1. export the registry branch 9375… to a new .reg file
2. open the new file in a text editor
3. do a find and replace for /<Profile Name>/ substituting the text between the slashes with your new profile name
4. save the reg file
5. double-click on the reg file to import it into the registry

If you did everything correctly, and the named profile exists, when you reopen Outlook, and go to Tools > Account settings… you should see your newly imported accounts:

It really does appear to be as simple as that. Yay

I’ve been interested in the internal structure of jQuery for as long as I can remember, but it can be overwhelming at the best of times, so I’ve recently made-good on my plan to build an interactive breakdown of the physical code.

Essentially, it provides a rather handy birds-eye view of the jQuery library, making it easy to dig into and understand the coding behind the seemingly-simple syntax.

Points of note:

• It breaks the physical JavaScript into visual blocks that you can easiliy navigate.
• Each block opens to reveal its internal code
• Clickable hyperlinks allow you to follow program flow

It now also has a few nice features such as:

• Live links to the online documentation
• Color themes
• Optional icons

Check it out here: http://www.keyframesandcode.com/resources/javascript/deconstructed/

This macro exports the current worksheet as a tab-delimited or comma-delimited text file, with the following features:

• optionally exports the current selection
• outputs values as text
• strips leading and trailing whitespace
• quotes any cells with spaces (TSV only)
• warns if the file is locked

Here’s an example of the two file outputs:

Tab-separated values

id	word	words
1	hello	"hello there"
2	goodbye	"goodbye then"
3	a	"a, b, c"

Comma-separated values

id,word,words
1,hello,hello there
2,goodbye,goodby then
3,a,a, b, c

Download ExportDelimitedText

Here’s what you do:

1. Note the size of your screen height in pixels (mine is 1024)
2. Measure the physical height of the pixel-area of your screen using a ruler (mine measured 27.0 cm exactly)
3. Divide the number of pixels by the number of centimetres (1024 / 27 = 37.925)
4. Enter this number in the Screen Resolution box under Preferences > Units & Rulers:

Photoshop will now display your images at the correct size when you choose View > Print Size.

However, it’s a bit of pain to have to go to the menu option each time, but an easy solution is to simply map View > Print Size to the CTRL + ` (top left key):

Now, you can easily swap between 100% and Print Size by alternating between CTRL+1 and CTRL+`

Luckily, I’ve found a way to trick it into not doing this.

Simply place a hidden password field, with no name, at the start of your form:

<input type="password" style="display: none;"/>

This seems to trick firefox into thinking that this is the main password field, but as there’s no name it a) doesn’t get set and b) doesn’t get submitted.

Great

Check it out online and have a play – I’ve tried to make it super easy, and there’s sample code you can use to get you started. Also, try copying and pasting some of the code Kohana classes in to see what happens!

However, I saw the PaperVision 3D classes had moved on a step from this, and had rather nice blocks at the top of each script with their logo, made out of characters. Why not extend this idea and actually build a small Flash application to let me build dirty-great big words that I can use in my scripts for navigation purposes?

Comment Headings

Edit the text in the left-hand text box to update the text in the right, then click Copy Text to copy the headings directly to the clipboard so you can paste to your IDE.

Note:Comment Headings works only with mono-spaced fonts! Mac users – you might have to experiment to find the best one.

Firefox 3 users: due to FF3’s mono-spaced font tracking, the characters below may not display correctly, but rest-assured that in the final downloadable utility, and your IDE, the headings will appear just fine.

Demonstration

To demonstrate the differences between a comment-headered file and a normal file, compare the following two files, and see how much easier it is to skim through the one with larger comment headings.

• A file with comment headings.
• A file with normal text-based headings.

Options

The following options are available to customize your headings:

• Font – Choose from 12 available fonts of varying sizes and styles
• Block – Various characters to create the block comments themselves
• Comment – Various leading-comment styles to suit different languages
• Delimiter – Various delimiter characters for the

Presets

If you change programming languages / tasks regularly, you can save time by storing oft-used combinations as presets. For example:

• Input presets – Your most common heading text combinations
• Output presets – Your most common settings for each language / editor / etc

Presets can be quickly called up by selecting them from the dropdown lists, which automatically updates related dropdowns as well as the output text.

Both Input Templates and Output Settings are stored in an editable text file, presets.xml, which is well-commented, allowing you to add or delete settings to suit your workflow.

To have the utility start with your chosen presets, for example having the MaxScript headings always open, just ensure its entry is first in the input list.

Customization

Once tinkering in the presets file, the following elements are configurable:

• Comments – Choose the leading comments (//, –, etc) according to programming language
• Blocks – Choose which characters you want to physically build the words from
• Delimiters – Choose which characters you want to use to delineate each comment block
• Fonts – Choose from any of 12 fonts to be available

3dsmax users

In order to display the full-block style of comments, you will need to set up the SCiTE editor to use the extended Unicode character set, and display code by default in a fixed width font. To do so, you will need to add the following lines to your User Preferences file:

code.page = 65001
character.set = 204
font.base = font:Courier New,size:10
font.comment = font:Courier New,size:9

Obviously this is only applicable if you are using 3dsmax 2008 or above.

Download

• Windows .exe version for Windows users
• Flash .swf version for Mac users

A framework such as Kohana is really useful when serving lots of dynamic pages, as it allows you organise both your thoughts and your code into folders, creating order from what could potentially be chaos, at the expense of having to adhere to a structured way of working, in this case setting up controllers and methods that are correctly mapped from URLs (routes).

Whilst this is necessary for dynamic pages that need access to models, helpers and such like, for static pages that literally just need to be output to the browser, it’s quite a lot of overhead, and your controllers can very quickly end up bloated with itty-bitty “view this page” methods.

What would be great would be some magic method to automatically handle static pages, without having to set up an actual controller and method, that way all you really need to create is the view file, and you leave your controllers folder nice and lean.

Note: this tutorial is for Kohana 2.2. I haven’t investigated how it will work with 2.3 and the routing yet. Please comment if you have something to add!

The Fallback controller

The solution is using a default or “fallback” controller that takes care of serving views from routes that don’t map to an existing controller and method.

Essentially, this new controller kicks in just after the routing has drawn a blank, locates the appropriate view file, then serves it – instead of serving a 404 page.

Step-by-step

Let’s a take a look at how this works in a step-by-step approach from Kohana’s perspective. Don’t worry – it’s actually pretty simple, I’ve just mapped it out specifically so you can see what’s happening every step of the way.

Let’s start with a route

• The user navigates to a route, lets say /about/company/history
• Kohana looks for
  • an about controller, with
  • a company method, and intends to supply it with
  • a history argument

Here’s the thing though, because we did’t want the hassle of setting up ALL our controllers with methods just to load views, our about controller doesn’t have a company method! So what is Kohana to do?

Let’s load the Fallback Controller!
Well, normally, a 404 page would be served, but using the magic of hooks, we’re going to give Kohana one last chance to do something before serving that horrid 404 page.

So:

• The system.post_routing hook kicks in, and due to the way we’ve set up the hook file
• It loads our Fallback controller, which is designed to do something useful with the route before bombing out.

Let’s have the Fallback Controller do it’s stuff and find the view!
In this case, we want it to attempt to find a view, so:

• The Fallback controller builds a path from the arguments /about that will (hopefully) map to a view, in this case views/main/about.php, then
• Attempts to find this view using Kohana::find_file, and
  • if found – loads the view!
  • if not found – serves the 404 page

Summary

Pretty useful, huh? Basically all that happened is

• Kohana couldn’t find a controller, so loaded a Fallback controller
• The fallback controller took the route and found a view
• Kohana loads the view (or the 404 page if the view didn’t exist)

OK, perhaps it’s time to look at some code

Code

You will need to create or edit code in 3 separate places:

1. Enable hooks in your application’s configuration file
2. Create a hook file which tells Kohana what to do in the system.post_routing event
3. Create the actual Fallback Controller that will do the finding and loading of your view files

.

application/config/config.php – Enable hooks in the main config file…

$config['enable_hooks'] = TRUE;

.

application/hooks/fallback_page.php – Add a hook file to the hooks directory…

Event::add('system.post_routing' ,'call_fallback_page');

function call_fallback_page()
{
    if (Router::$controller === NULL)
    {
        Router::$controller = 'fallback_page';
        Router::$arguments = Router::$segments;
        Router::$controller_path = APPPATH.'controllers/fallback_page.php';
    }
}

.

application/controllers/fallback_page.php – Set up a controller to do the business

class Fallback_Page_Controller extends Page_Controller // page controller is my standard page template
{

    public function __construct()
    {

    // the constructor can be omitted if you're not doing anything special,
    // as the parent constructor it is called automatically
        parent::__construct();
    }

    public function __call($function, $arguments)
    {

    // search for a view, and load it if it exists
    // it's up to you how you handle the mapping of arguments to folders here!
        $route =  implode('/', $arguments);
        if(Kohana::find_file('views/main', $route))
        {
            $this->template->content = new View('main/'.$route);
        }

    // display alternative content if not found
        else
        {
            $view = new View('common/404');
            $view->info = array($function, $arguments);
            $this->template->content = $view;
        }
    }

}

Conculsion

So now you should be able to set up a bunch of views, but needn’t worry about building controllers for them if nothing exciting is happening.

The fallback controller will run, will attempt to find a matching view, and if found, will echo it the page. The main thing is – it keeps your controllers folder and classes nice and lean, and you only need to build controllers that actually DO any controlling!

Nice.

For this reason, here’s my attempt at a more integrated helper class. It’s somewhat of a Frankenstein’s monster with bits borrowed from Code Igniter, and my own code thrown in as well. Apart from this, it:

• Adds a few new methods
• Improves on some existing methods
• Combines the ‘download’ helper functionality
• Tidies up various method calls

The methods are:

• map()
• get_folders()
• get_files()
• delete_files()
• read_file()
• write_file()
• make_path()
• download()

Download filesystem.php here.

map ($path, $levels = NULL, $structured = FALSE, $files_first = FALSE)

Returns a hierarchical array of folders and files from the specified path.

The parameters are

• path : string – path to the folder
• [levels] : number – limit how many folders deep you want to recursively scan
• [structured] : boolean – split each returned branch into ‘/folder’ and ‘/files’ sub-arrays
• [files_first] : boolean – if not returning as a structured array, list files before folders

get_folders ($path, $appendPath = false)

Returns an array of folders from the specified path.

The parameters are

• path : string – path to the folder
• [append_path] : boolean – append the original path to the return output

get_files ($path, $mask = NULL, $appendPath = false)

Returns an array of files from the specified path.

The parameters are

• path : string – path to the folder
• [mask] : mixed – a file mask to determine which files to return. Can be either
  • null – all files
  • string – a single file extension
  • array – an array of file extensions
  • regular expression – any valid regular expression, for example ‘/^config/’
• [append_path] : boolean – append the original path to the return output

delete_files ($path, $mask = NULL, $del_dir = FALSE, $del_root = FALSE)

Recursively deletes all files and optionally folders from the specified path.

The parameters are

• path : string – path to the folder
• [mask] : mixed – a file mask to determine which files to delete. Can be either
  • null – all files
  • string – a single file extension
  • array – an array of file extensions
  • regular expression – any valid regular expression, for example ‘/^config/’
• [del_dir] : boolean – delete any directories encountered when prcoessing
• [del_root] : boolean – delete the root directory after processing

read_file ($file)

Opens the specified file and returns its contents as a string.

The parameters are:

• file: string – path to the folder

write_file ($path, $data, $append = FALSE)

Writes data to the specified file.

The parameters are

• path : string – path to the folder
• data : string – the data you want written to the file
• [append] – boolean – optionally append data to the file, rather than overwriting it

make_path ($path, $permissions = 0755)

Recursively create folders to form the specified path.

The parameters are

• path : mixed – path or an array of paths
• [permissions]: number – permissions you want granted to the new folders

download ($filedata, $filename = NULL)

Download file content by popping up a download dialog in the user’s browser.

The parameters are

• filedata : mixed – can either be
  • filepath – the path to an existing file
  • string – data you want downloaded as a file
• [filename] : string – a filename that will appear in the user’s download dialog

Sometimes you just want to store lists of name/value pairs, to keep track of a few settings throughout your script, without relying on a host of variables, resorting to .ini files, or custom attributes.

Therefore, I set about writing a basic Dictionary, or List struct, similar to VB and other languages.

Example code

Here’s a really basic example of storing 5 named variables within a List:

names = #("five", "four", "three", "two", "one")
values = #(5,4,3,2,1)
lst = List()

for i = 1 to 5 do lst.addItem names[i] values[i]

So let’s get some data back out:

lst.getValue "two"
-- 2

lst.getIndex "two"
-- 4

lst.getValues()
-- #(5, 4, 3, 2, 1)

Or print the whole lot:

lst.print() -- unsorted

five:	5
four:	4
three:	3
two:	2
one:	1

How about some sorting:

lst.sort() -- by name, alphabetically

five:	5
four:	4
one:	1
three:	3
two:	2

lst.sort field:#value -- by value

one:	1
two:	2
three:	3
four:	4
five:	5

As you can see, it’s pretty straightforward stuff!

Properties and Methods

Properties

• <array> items <name> <value> – the key/value pairs.
  • Names can be a #name, “string”, or even an index
  • Values can be any MaxWrapper value (i.e. anything)

Setters

• <ListItem> addItem <name> <value> – adds an item to the List, and if it already exists
• <ListItem> setItem <name> <value> – synonym for the above

Getters

• <value> getValue <name> – returns the value of the named item
• <index> getIndex <name> – returns the index of the named item
• <name> getName <value> – returns the name of the first item that matches the supplied value
• <ListItem> getItem <name> – returns the List item corresponding to the supplied name (typically, you wouldn’t use this, as you know the name component already, it’s just included for completeness)
• <array> getItems() – returns all items as an array of ListItem structs
• <array> getNames() – returns all names as an array
• <array> getValues() - returns all values as an array

Clear or delete

• <array> clear() – clears the lit of all items, and returns the empty ListItems array
• <boolean> deleteItem <name> – deletes the named item from the list, and returns it
• <boolean> deleteIndex <index> – deletes the item at the index, and returns it

Utilities

• <array> sort field:<name> order:<name> func:<function> – sorts the list in a variety of ways, even supply a comparison function (see the max help on qsort)
• <string> print() – prints the List items to the Listener

Next version

Possible improvements in the next version might be:

• .ini file integration, with save() and load() methods
• Support for hierarchical Lists, perhaps getValue #(#parent, #child, #grandchild, …)

Download

Download List.struct.ms here.