Since I have multiple calendars and multiple email accounts, it is often that I want to choose the specific account when sending an invitation or reply to an invitation. This tar file contains the AppleScript changes necessary to create a selection box prior to sending these emails. Once a sending address is selected and OK is clicked, Mail.app will proceed with sending the iCal invitation or reply from the account corresponding to the email address.

To use this, follow these instructions:

Quit iCal!

Backup iCal.app!

mkdir ~/Desktop/LeopardiCalBackup

sudo rsync -Eav --delete /Applications/iCal.app ~/Desktop/LeopardiCalBackup

sudo hdiutil create -format UDRO -srcfolder ~/Desktop/LeopardiCalBackup -volname LeopardiCalBackup ~/Desktop/LeopardiCalBackup.dmg

sudo rm -rf ~/Desktop/LeopardiCalBackup/

Copy the dmg file somewhere safe.

Extract the modified AppleScript files:

(assumes iCal.app is in /Applications and LeopardiCalSelectSender-20071127.tar is in ~/Desktop)

cd /Applications

tar xvf ~/Desktop/LeopardiCalSelectSender-20071127.tar

Run iCal.app, send an invitation and reply to one, test out the ability to select the sender for the Mail.app outgoing email.

In rough order, I do the following:

1. Shoot the photos (of course).
2. Store them in a hierarchical folder structure that fits my organization scheme.
3. Create a new Adobe Lightroom Library specifically for the photo shoot.
4. Create a collection (usually named Color4×6) within the library and drag all the “keepers” into the collection.
5. Manipulate each keeper for exposure, tone, contrast/brightness, sharpness, etc.
6. Crop for 4×6 (1.5:1 is my camera’s aspect ratio) sized prints.
7. Make collections for each of the print sizes I intend (Color5×7, Color8×10).
8. Select all in Color4×6 and choose Make Virtual Copies — this leaves the newly created virtual copies selected.
9. Drag virtual copies (left selected by last command) to one of the other collections.
10. Delete the virtual copies within the source collection.
11. Select the destination collection and recrop all photos for the new aspect ratio.
12. Repeat 8, 9, 10 for all other print sizes.
13. Make collections for each of the print sizes I intend in B&W (B&W4×6, B&W5×7, B&W8×10).
14. Select all in one of the Color collections and choose Make Virtual Copies.
15. Drag virtual copies (left selected by last command) to the corresponding B&W collection.
16. Delete the virtual copies within the source collection.
17. Select the corresponding B&W collection, select all photos and Convert to Grayscale.
18. Repeat 14, 15, 16, 17 for all of the other print sizes to be output in B&W.
19. Output each of the collections to its own directory on the filesystem. I use TIFF 16bpp color, sRGB 300dpi, no maximum size constraints.
20. In each of the color output directories, I run a script that either converts the image to JPEG at quality 90 and 8 bpp color or up-samples it to the correct resolution for the dpi desired (e.g. 1200×1800 for a 4×6) and converts to JPEG at quality 90 and 8bpp color.
21. In each of the B&W output directories, I run a script that adds random film grain to the image with a hardlight screen operation. Subsequently I perform the same up-scale and/or convert to JPEG performed in step 20.
22. For each of the final JPEG files, I use a script to identify the source NEF image (I shoot all RAW) and call negtags2jpg to migrate the EXIF data into the JPEG, as the ImageMagick command line utilities I use to make my manipulations do not properly migrate the tags from TIFF to JPEG.
23. Create a web gallery for the color images using HtmlGallery against the Color4×6 output.
24. Create a web gallery for the B&W images using HtmlGallery against the B&W4×6 output.

To wrap it all up I upload the final JPEG files to an online printing house and archive the JPEG and web gallery output along with the Adobe Lightroom Library, original NEF files and XMP sidecar files.

#!/usr/bin/perl
# All of the documentation and software included in this software distribution
# is copyrighted by Matthew C. Mead (m-web@goof.com).
#
# Copyright 2007, Matthew C. Mead.  All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the distribution.
# 3. All advertising materials mentioning features or use of this software
#    must display the following acknowledgement:
# This product includes software developed by Matthew C. Mead.
# 4. Neither the name of the author nor the names of any co-contributors
#    may be used to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY MATTHEW C. MEAD ``AS IS'' AND ANY EXPRESS OR
# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
# EVENT SHALL MATTHEW C. MEAD OR CO-CONTRIBUTORS  BE LIABLE FOR ANY DIRECT,
# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

my $portraitGrain = "/Users/mmead/Desktop/grain-portrait.png";
my $landscapeGrain = "/Users/mmead/Desktop/grain-landscape.png";

my $composite = "composite";
my $identify = "identify";

if ($#ARGV != 1) {
print "Usage: addgrain.pl  n";
exit 1;
}

my $source = shift;
my $dest = shift;

my $landscape = 0;
my $grainsource;

open ID, "$identify $source|";
my $id = ;
close ID;

my ($width, $height) = $id =~ /s(d+)x(d+)s/;
if ($width > $height) {
$landscape = 1;
$grainsource = $landscapeGrain;
} else {
$grainsource = $portraitGrain;
}

open ID, "$identify $grainsource|";
$id = ;
close ID;
my ($gwidth, $gheight) = $id =~ /s(d+)x(d+)s/;

if (($width > $gwidth) || ($height > $gheight)) {
print "Grain source not large enough for source image.";
exit 1;
}

my $deltaWidth = $gwidth - $width;
my $deltaHeight = $gheight - $height;
my $offsetWidth = int(rand($deltaWidth));
my $offsetHeight = int(rand($deltaHeight));

system $composite, "-extract", "${width}x${height}+${offsetWidth}+${offsetHeight}", $grainsource, "-compose", "hardlight", $source, "-quality", "90", "-depth", "8", $dest;

I’ve not had much need for a color-based filter for any of my digital cameras. I always use an UV/haze filter for protection of the front element and take that off to use a circular polarizer when shooting outside or against glass.

From my first digital camera forward I have found it very important to experiment with white balance settings and know how the camera behaves in differently light sources. On some cameras auto works very well in many light sources, on others, not so many, or only specific light sources. One thing has rung true for me across all my cameras, though: using the direct sun white balance preset for sunsets yields colors in the picture that look like the real thing to my eyes.

My general recommendation is to shoot RAW with auto (or preset based on light source). Change the white balance in post processing later if the white balance chosen does not properly capture colors. With RAW the camera’s white balance setting does not effect your final output because you can adjust it with software without incurring any color sampling loss. Conversely, with JPEG you can also adjust it with software, but you will have some color sampling loss in the conversion as well as JPEG compression generational loss if your ultimate output format is JPEG.

If you’re really interested in a “filter” for a specific setting, get a grey card and take a white-balance reference photo in the lighting where you’ll be shooting. You can use that to later adjust white balance in post processing by using software to examine the white balance the camera chose based on its exposure of the grey card. You may be able to tell the camera itself (through its menu) to use the shot of the grey card to preset its white balance (often called custom or reference white balance). Then it should be spot on for the lighting as long as the lighting conditions don’t change while you’re shooting.

I didn’t try a newer version of Typo (4.03) before long before migrating.  Typo seems to be consuming way too much RAM and swap for the mix of uses my host performs.

First, set the DHCP Options as you desire for the private network. I use the default of 10.37.129.0/24:

Then configure the networking for the Virtual Machine to be Host Only Networking:

Finally, boot the VM and configure it to use a static network configuration:

ip: 10.37.129.x

netmask: 255.255.255.0

default router: 10.37.129.1

dns: whatever it’s set to on your Mac’s /etc/resolv.conf

For dns, I run a copy of dnscache on my Mac with options that allow for it to serve requests on 10.37.129.0/24, and specify 10.37.129.1 as the dns server to my VMs.

Create a directory /Library/StartupItems/Firewall and create a file in it called StartupParameters.plist with the following contents:

{
Description     = "Firewall";
Provides        = ("Firewall");
Requires        = ("NetworkExtensions","Resolver");
OrderPreference = "Late";
Messages =
{
start = "Starting firewall";
stop  = "Stopping firewall";
};
}

Create a file in the same directory called FirewallManual:

#!/bin/sh

##
# Firewall
##

. /etc/rc.common

StartService ()
{
ConsoleMessage "Starting Firewall"
sh /etc/rc.firewall > /dev/null
}

StopService ()
{
ConsoleMessage "Stopping Firewall"
/sbin/ipfw -f -q flush
/usr/bin/killall natd >/dev/null     2>&1
/usr/sbin/sysctl -w     net.inet.ip.forwarding=0
}

RestartService ()
{
StopService
StartService
}

RunService "$1"

Finally, create /etc/rc.firewall with the following contents:

#!/bin/sh

DEFROUTE_IF=`/usr/sbin/netstat -rn | /usr/bin/awk '/^default/ {print $6;}'`
NATD=/usr/sbin/natd
NATD_OPTIONS="-log -log_denied -use_sockets -same_ports -interface $DEFROUTE_IF"
IPFW=/sbin/ipfw

LOOPBACK="lo*"
PUBLIC_IF="$DEFROUTE_IF"
PARALLELS_IF=en2

PARALLELS_NET="10.37.129.0/24"

# start natd
$NATD $NATD_OPTIONS

# divert traffic before anything else
$IPFW add 01000 divert natd all from $PARALLELS_NET to any out via $PUBLIC_IF
$IPFW add 01010 divert natd all from any to any in via $PUBLIC_IF

# standard mac os x firewall stuff
$IPFW add 02000 allow ip from any to any via $LOOPBACK
$IPFW add 02010 deny ip from 127.0.0.0/8 to any in
$IPFW add 02020 deny ip from any to 127.0.0.0/8 in
$IPFW add 02030 deny ip from 224.0.0.0/3 to any in
$IPFW add 02040 deny tcp from any to 224.0.0.0/3 in
$IPFW add 02050 allow tcp from any to any out
$IPFW add 02060 allow tcp from any to any established
$IPFW add 02070 allow tcp from any to any dst-port 22 in
$IPFW add 02070 allow ip from any to any dst-port 53 in
$IPFW add 02080 allow tcp from any to any dst-port 80 in
$IPFW add 02090 allow tcp from any to any dst-port 427 in
$IPFW add 02100 allow tcp from any to any dst-port 443 in
$IPFW add 02110 allow tcp from any to any dst-port 5297 in
$IPFW add 02120 allow tcp from any to any dst-port 5298 in

#$IPFW add 03000 allow all from $PARALLELS_NET to any via $PARALLELS_IF in
#$IPFW add 03010 allow all from any to $PARALLELS_NET via $PARALLELS_IF out

$IPFW add 12190 deny tcp from any to any
$IPFW add 65535 allow all from any to any

sysctl -w net.inet.ip.forwarding=1

Make both /Library/StartupItems/FirewallManual and /etc/rc.firewall mode 755.

Now all the pieces are in place…

In order to use this, you need to start Parallels and bring up the VM you’ve setup above. Once that is done, open System Preferences, Sharing, Firewall and stop the firewall. Then from the command line, run:

sudo /Library/StartupItems/Firewall/FirewallManual start

Your guest VM should now have NAT’d internet access via the default route in place on your Mac.

To tear things down, run

sudo /Library/StartupItems/Firewall/FirewallManual stop

Then start the firewall in the Sharing pane of System Preferences, and all is normal.

Please note that there are a number of rules that open specific ports in the above. You should ensure those ports are what you’d like to have open if you intend to use this script.

Use how you like at your own risk, there is no warranty provided. If you’d like to use this as source material to make a nice GUI on top of this, please let me know so I can grab it and use it. For now this works very efficiently for me, though an on off button that automates most of this and an installer would be cool. If I were doing it I would:

• Collect the set of firewall rules in place after starting the Mac OS X default firewall via AppleScript.
• Wrap those rules with the rules necessary to allow Guest VM <-> Mac communication, NAT diversion and packet flow.
• Perform a similar start process to above when a button was pressed.
• Perform a similar stop process to above when a button was pressed (including restart of Mac OS X default firewall via AppleScript).

I have not researched to see how much of this is possible, but my guess is most of it is, or the information to implement the same thing can be gleaned by reading plist files that contain the firewall settings.

MythFrontend-MacOSXUniversal-0.20-fixes-20061001.dmg.bz2