LiveReload is a tool for web designers. It watches for changes in a given folder and–in a way similar to what Marked does for Markdown files–it updates your web browser(s) whenever files with certain extensions change. Yes, you can (and I have) script your way to something similar, but LiveReload brings a few extra refinements to the job.

You have the option of adding a JavaScript snippet to the head of your HTML files on your development server, or (far better) you can use browser extensions in Safari, Firefox and Chrome. With either of these options in place, the coolest part of LiveReload becomes available: any changes to images or CSS are reflected live–and instantly–on the page without a reload. It’s not quite as “live” as Espresso, but it brings instant-preview editing to any of your favorite editors. Just add the watch folder, turn on the browser extensions and start saving. It also makes it possible to see previews in Gecko and Webkit browsers simultaneously without manually refreshing.

LiveReload has some powerful customizable options. You start by telling it which folders to watch, but you can get specific about which filetypes to watch as well. You can have it automatically compile SASS, LESS, CoffeeScript and others and control the output location for every individual file (if you like). You can also specify any shell command to run after changes are processed but before the browser refreshes. There’s really not much you can’t do with a setup like this.

LiveReload is in beta right now, but the development schedule appears to be on track. It’s ultimately headed for the App Store, and I don’t know what it will cost. If the price is reasonable for an app that I consider to be very useful–but could live without–I’ll definitely be picking up a copy when the time comes. There’s also a Windows version in the works, which might even help me solve some IE testing conundrums. We’ll see. For now, check out the beta, grab the browser extensions and see what you think.

Related posts:

1. LiveReload addendum
2. nvALT Browser Extensions
3. App Review: Dropzone

Originally posted on BrettTerpstra.com at App Review: LiveReload

This is the last of this run of Thanksgiving giveaways. There will be more soon, I promise, but Smile was generous enough to donate–in addition to the TextExpander licenses I gave away yesterday–three codes for PDFpen as well. I don’t usually run giveaways on apps I haven’t specifically reviewed, so I’ll try to roll both together here.

PDFpen is an amazing tool for anyone who works with PDF files. It can do OCR (Optical Character Recognition) on scanned documents to turn them into editable text, and it provides tools for correcting, annotating and redacting that text. It can handle digital signatures, too, so you can sign and return a PDF contract or paperwork without ever having to print or scan. It can fill forms, compress files, merge documents… it’s a workhorse and on par with Adobe Acrobat Pro in just about every regard (except for the areas it’s even better at).

The standard license for PDFpen on the App Store is US $59.99, and there’s a Pro version available for US $99.99 which adds form creation, website saving and table of contents generation. I have three App Store codes for the standard version to give away.

As always, just leave a comment on this post and you’ll be added to the list for the Giveaway Robot to randomly select from. One comment per person, please, and use a unique name to make announcing the winners easier. The drawing will take place at noon on Monday, December 5th. Drop a comment before then for a chance at a $60 app, free!

Related posts:

1. Mac App Giveaway: TextExpander
2. Mac App Giveaway: Byword
3. Mac App Giveaway: Dropzone

Originally posted on BrettTerpstra.com at Mac App Giveaway: PDFpen

There’s a new version of Marked on the horizon with a few new features, and one a little down the road with built-in support for more applications (that aren’t necessarily straight text editors). Enter for a promo code (by leaving a comment on this post) and you’ll have a chance at a free copy ($3.99). In addition to a fine app, winners will, of course, get free updates as they come out. Winners will be drawn at random from the comments on this post at noon on Saturday, December 3rd. Good luck!

Related posts:

1. Marked 1.3 drawing winners
2. Marked 1.3 released, plus 5 free copies!
3. Marked is on the Mac App Store

Originally posted on BrettTerpstra.com at The second Marked giveaway!

Leave a comment below to be entered in the drawing. The “robot” will be randomly selecting winners from the list on Friday, December 2nd at noon. The lucky winners will be notified by email (so use a valid address on your comment). Good luck, and be sure to check out all of the other great giveaways running right now!

Related posts:

1. Mac App Giveaway: TextExpander
2. Mac App Giveaway: PDFpen
3. App Review: Byword

Originally posted on BrettTerpstra.com at Mac App Giveaway: Byword

The latest version in development includes some really exciting new features:

• A HUD panel shows a list of labels that have been defined in your document that can be used when creating links, footnotes, citations, etc. This can be used to remind yourself of which label you used previously to define an element by reference. Another HUD panel shows word, paragraph, and character counts for your documents.
• A group of new key commands for selecting and moving parts of your document around without using the mouse, as well as for creating and cleaning up lists automatically.
• Composer now uses UTIs to define which documents it can open/save. This will have several behind-the-scenes benefits when it comes to saving, opening, previewing, and indexing documents for Spotlight searches.
• Significant improvements to responsiveness when working with long documents (e.g. using the ToC to scroll).
• Improved support for font-size and font-family in stylesheets. These will help my own themes work more smoothly.
• Plenty more!

Picking up a license now gets you free access to all of the new features when they’re released. Comment below for a chance at one of the five licenses (App Store US $9.99). Winners will be drawn at random (by the Giveaway Robot) on Thursday, December 1st at noon.

Notification is via email, so be sure to use a valid address. It’s also helpful to use a unique name (first and last preferred, but anything to help avoid duplicates) so announcements of the winners don’t get the other “Rob” or “Jim” all excited, only to be disappointed when they figure out it wasn’t them.

There are still a few more (very exciting) giveaways coming up over the next couple of days, so keep checking back. There’s no rule against entering for all of them (once each, please, or the robot gets angry. You don’t want to see him angry), so keep at it!

Related posts:

1. Mac App Giveaway: PDFpen
2. Marked is on the Mac App Store
3. Break up your text documents

Originally posted on BrettTerpstra.com at Mac App Giveaway: MultiMarkdown Composer

Winners will be drawn at noon on Wednesday, November 30th and notified by email. Please use a valid email address and a unique name (to make announcing the winners easier). One entry per person per giveaway, but feel free to enter for every giveaway I’m running this week! I have a lot of amazing applications to share right now… keep checking back, there are at least three more coming before this madness ends!

Smile, the company behind TextExpander, is also running their own special for Black Friday. Today only, get PDFPen or PDFPenPro for 50% off. It’s the perfect time to jump on one of the most powerful tools available for creating fillable forms and working with PDF files.

Related posts:

1. Mac App Giveaway: Byword
2. Mac App Giveaway: PDFpen
3. Mac App Giveaway: MultiMarkdown Composer

Originally posted on BrettTerpstra.com at Mac App Giveaway: TextExpander

Leave a comment on this post to enter. Five winners will be randomly selected from the comments on Thursday, December 1st at noon and notified by email.

Related posts:

1. Mac App Giveaway: Byword
2. Mac App Giveaway: TextExpander
3. The second Marked giveaway!

Originally posted on BrettTerpstra.com at Mac App Giveaway: Dropzone

Yet another giveaway here at brettterpstra.com. We’re wheeling, we’re dealing… and I got you five licenses for the excellent QuickCal application for Mac (and iOS, but we’re not giving those out… yet). If you haven’t used it, it’s a way to add events and todos to your calendar using natural language. I could say, for example, “End the QuickCal giveaway noon on Wednesday” and I’d get a new calendar event set for noon on Wednesday, October 05, 2011 with the title “End the QuickCal giveaway.”

I wrote about a recent version at TUAW if you’re looking for more in-depth coverage. Trust me when I say this is one of those apps that can change the way you work with your calendar. It works with iCal, BusyCal and Google Calendar and includes conflict detection and smart reminders. Leave a comment for a chance to pick up a free license! The drawing will occur on Wednesday at noon.

QuickCal has a sweet video on Vimeo if you want to watch the magic happen.

Related posts:

1. The QuickCal winners
2. Mac App Giveaway: TextExpander
3. Quick Link: Bro Show #85

Originally posted on BrettTerpstra.com at What? You want QuickCal for free? Ok.

In the interest of actually getting going on app reviews on this blog, I’m mentioning a somewhat obvious one: Byword. While I still write my drafts in nvALT and do the heavy lifting and linking in TextMate with my Blogsmith Bundle, Byword has quickly become the place where I actually do my writing.

I’m not a big advocate of “distraction-free” writing. I’ve never found that I need it, despite my ADD and generally short attention span. The fact is that as I write I’m constantly checking facts and links in my browser, and it’s mostly pointless to keep switching screens to do that. Byword is great for me because it doesn’t focus solely on the distraction free aspect. Full-screen and “focus” modes are available, and it does a beautiful job with them, but it puts an equal amount of effort into just creating a pleasant atmosphere for writing. Great themes, great fonts and even some of the Markdown-specific tools (auto-pairing, wrapping and list continuation) that I’m always begging for.

Byword’s developerOne of Byword’s developers, Jorge Pedroso, has told me that nvALT and some of my other projects were an inspiration for the Markdown features in Byword, which is hugely flattering to me. He’s also released a custom stylesheet for Marked which brings Byword’s beautiful styling to any Markdown document.

If you write, whether it’s long-form or quick blog posts, Byword is an excellent way to do so. There’s a lot of competition in this field; I’ve tried them all (seriously), but Byword has become my writing tool of choice on the Mac. You can pick it up on the Mac App Store for $9.99 US and it’s worth every penny.

Related posts:

1. Mac App Giveaway: Byword
2. iOS App Review: WriteUp
3. Sticking with what I know

Originally posted on BrettTerpstra.com at App Review: Byword

I like the Mac App Store. I’ve purchased a lot of apps since it opened, and I dig the centralized update system. I’ve been having this issue on my MacBook Air, though, where trying to update an installed app would trigger a dialog which says “You have updates available for other accounts…” and suggest that I log in with that account to update my software. Thing is, I only have one Apple ID, one account.

After digging around and trying various things, I found this thread in the Apple Support Communities. The solution, buried in there somewhere, was to both repair disk permissions in Disk Utility and rebuild my Spotlight index. You can rebuild your index simply by adding your entire hard drive to the Privacy settings in Spotlight’s System Preferences panel and then removing it. You can do it from the command line or from a utility such as Cocktail¹, too, but don’t make it complicated.

After doing both (in that order), I’ve been able to update without hassle. Somehow, it made LaunchBar stop indexing my applications, but I’ll figure that out when I have time…

Related posts:

1. Quick Tip: Extracting Mac App Store reviews as text
2. A cheat sheet for App Store pricing
3. Tunesque 1.1.2

Originally posted on BrettTerpstra.com at Quick Tip: fixing the “other account” Mac App Store issue

Courtesy of Buzan Center Australia.

Most of my projects start out as mind maps (which I may have mentioned before). Whether it’s a packing list, a blog post or a TextMate bundle, I find it easiest to organize my (often scattered) thoughts using what Tony Buzan calls radiant thinking. Lists and outlines are rarely as effective as the non-linear format of a mind map. For me, if it involves brainstorming, it involves mind maps.

This post isn’t about how to mind map (but this one is). It’s a summary of the process by which I settled on my current set of tools. I used Mindjet MindManager (Mac) together with the web app MindMeister for years. As with all things in the Mac app world, I played with every mind mapping application that came out, but only recently have I found myself actually looking for a new workflow. It has, primarily, to do with three things: frustration with MindManager, the advent of the iPad, and a wealth of new alternatives. I’m currently down to a collection of solutions across three platforms (Mac, iOS and web) which meet all of my requirements and offer interoperability with each other and other tools in my workflow.

What went wrong with MindManager

In my opinion, MindManager is still the most powerful mix of ease-of-use, OS integration and aesthetic options on the market. In recent years, though, it’s been apparent that the Mac platform has become an afterthought for the developers. The Windows versions are taking leaps and bounds, and the Mac version has little parity with its feature set. The new features in the last $99 upgrade were pretty much useless to me; in my workflow they were just feature bloat. The decision to find something else was based mostly on disappointment with the development and what I consider to be unduly expensive prices, even for existing customers.

The options

Here’s my checklist of features that I knew I needed in any app I was going to consider:

• Intuitive keyboard navigation
• The ability to visually connect non-contiguous nodes
• Support for images
• Sufficient export options
  • at the least, OPML, PDF and a format interoperable with other mapping applications (Freemind is pretty standard)
• The ability to import other mind map formats, and preferably OPML
• Smart/auto layout (moves existing nodes out of the way of new nodes without interaction)

On the Mac

There’s a fairly wide field of options to consider. I’m quite certain I’ve tried everything available on both Mac and iOS at this point. For Mac, these include NovaMind, iMindMap, Freemind, MindNode, XMind and Curio, among others. I already use Curio for project management, and it’s an excellent choice for any information gathering and organization, but I find it to be overkill when I just want to mind map. I also ruled out NovaMind because I found it a bit unwieldy, though I think that the developer is onto some great things. I ruled out Freemind because it’s old and ugly, and I’m prejudiced like that. XMind and iMindMap are nice and easy to use, but their Java roots and lack of OS integration were turnoffs for me. The one that met my needs and my standards almost perfectly was MindNode Pro.

In a nutshell, MindNode is a minimalist mind mapping application that does exactly what it needs to. It’s easily usable with just the keyboard (customizable shortcuts, even), handles auto-coloring and map layout smoothly and integrates with standard OS X media options and features. You can quickly customize a limited set of options (branch color, font, node width) using standard palettes and tools, and you can add images, audio and file links quickly via drag and drop or from a media palette (with Quick Look support). In short, it meets my needs and has zero feature bloat.

On the web

There’s really only one option for web-based mind mapping that I’ve found worthy: MindMeister. It’s nearly as nice to use as a desktop app, has some very cool extra features without being too heavy, and its import and export options fit perfectly in my workflow. It can also share embedded, interactive maps.

The Geistesblitz feature uses the (extensive) API to make it possible to add quick thoughts to a map from just about anywhere: Dashboard, a web browser, iPhone, iPad, etc. The API has also allowed me to integrate similar functionality into LaunchBar, QuickSilver and TextMate, to name a few. Best of all, it supports live collaboration with realtime updates, chat and permission control. If I’m collaborating with others I run it in Fluid instead of using a desktop application.

On the iPad

There are some amazing options for mobile mind mapping. I won’t list them all, just the ones I actually use:

• MindNode
• iThoughts HD
• MindMeister

There are other, more general options for brainstorming which have also made it onto my homescreen, such as Popplet, OmniGraffle, Idea Boards and HeadSpace, but I’ll keep this focused on traditional mind mapping apps.

MindNode for iPad is an obvious choice for me, with great interaction with the desktop version and available sharing options. It’s as easy to use and as minimalist as MindNode Pro is on the Mac. I couldn’t stop using iThoughts HD, though… it has an awesome feature set and its export options mix well with my other choices. The native MindMeister app also mixes well, integrating with the web version and exporting formats I can import to other apps. I use MindNode when I know I’m going straight to my desktop when I’m done, iThoughts HD for standalone, mobile mapping with portability options and MindMeister for any collaborative efforts, as well as quick, single thoughts.

Since we’re talking about mobile brainstorming, I would be remiss not to acknowledge the utility of the original mind mapping app: paper. A Moleskine and a basic understanding of mind mapping principles provide all the tools you need to brainstorm anything, anywhere. The major benefit that the iPad has is instant, on-the-fly reorganization and modification of nodes, as well as portability to other mediums. OPML will get you from a mind map to a Scrivener document, an OmniOutliner project or even good old Markdown.

A flexible workflow

With this collection of tools I can use the right app for the job in any given situation¹. By considering export options, I can always be sure that whatever I create will translate to other platforms and structures. As an added benefit, all of these options combined still cost less than half as much as buying the desktop version of MindManager.

Each of these apps has their own neat tricks and features. For example, in the web version of MindMeister you can select a node and hit the image button (don’t trigger the dropdown) and you’ll get a random (but usually sensible) image for the node. It works with the link button, too, adding a Wikipedia or other link based on the node’s text. In MindNode, select all and copy, then paste into a text-based application. You’ll get an indented list of your nodes, in order from top right moving clockwise around your map. This is a great way to get your thoughts from map to outline when writing, without dealing with OPML export and multiple applications. I use a homebrew System Service² to convert it to a Markdown outline in any text editor.

If you haven’t tried mind mapping, grab any of these apps (or a good book) and see if it’s a fit for the way you think. I personally believe that the method is superior for any type of thinker, but I only have one thought type to compare. If you dig it, hopefully these results of my extensive “fiddling” will help you begin building a toolset that’s right for you.

Related posts:

1. When plain text is wrong
2. Quick Tip: MindManager to (clean) HTML
3. The MindMeister Markdown Showdown

Originally posted on BrettTerpstra.com at The Mac and iOS mind mapping app extravaganza

I bought a MacBook Air recently. I have never been this happy with an Apple hardware purchase before. Not to gush, but I’ve bought and loved a lot of Macs and this one takes the cake. I’m doing more and more of my everyday work and writing on it, but I still like to sit down at the dual-monitor setup of my Mac Pro fairly regularly. When I do that, the Air becomes an auxiliary machine and I offload most of my chat and social apps to it. The annoying side of this setup is that I end up with Safari tabs piling up on both Macs, and half of them really make more sense on the other machine.

I wrote a pair of scripts that execute over SSH to pull in all of the browser tabs from the front window of Safari on the other Mac into new tabs on the one calling the script. They’re designed to run on Macs on the same network, though they’d work remotely if you could think of a reason to do it. I run it in both directions, and call it with a simple do shell script AppleScript in ~/Library/Scripts/Applications/Safari so it’s in my menubar when I’m browsing.

Just a few prerequisites:

1. You need keyless ssh set up between the two (or more) Macs. If you want a two-way sync, you need keys in both directions. This article has everything you need.
2. To keep things simple, set up a ~/.ssh/config file on each machine you want to pull tabs to. Create the file if you don’t have one, or add this at the bottom of an existing one, modifying it for your setup:

host air
  HostName computername.local
  User remoteusername

Now you can just install the scripts, edit one line on each and start pulling tabs back and forth between computers.

remotetabs.rb

This goes on the machine you want to pull from. If you’re going both directions, you’ll want both scripts on both machines. Easy enough, right? Save this one as remotetabs.rb in ~/scripts/ and run chmod a+x ~/scripts/remotetabs.rb. Note that it doesn’t attempt to do any error reporting, it just fails silently or times out if there’s a problem. You’ll know something went wrong, you just won’t know what. It’s mysterious, enjoy it.

Because I often run Webkit, and because Webkit demands that it be addressed separately from Safari, there’s a quick check in here to see which one is running at the time.

#!/usr/bin/ruby

def app_running?(app)
  not `ps ax|grep -i "#{app}.app"|grep -v grep`.empty?
end

def webkit_running?
  return false if `ps ax|grep -i "Safari.app"|grep -v grep`.empty?
  not `ps ax|grep -i "/Applications/Webkit.app"|grep -v grep`.empty?
end

if app_running?("Safari")
  browser = webkit_running? ? "Webkit" : "Safari"
  urllist = %x{osascript <<-APPLESCRIPT
               tell application "#{browser}"
               set _tabs to every tab of window 1
               set _urls to {}
               repeat with _tab in _tabs
               set end of _urls to URL of _tab
               end repeat
               set {astid, AppleScript's text item delimiters} to {AppleScript's text item delimiters, " "}
               set output to _urls as text
               set AppleScript's text item delimiters to astid
               return output
               end tell
               APPLESCRIPT }.chomp
  puts urllist
end

getremotetabs.rb

This goes on the machine that's doing the "pulling." Save it as getremotetabs.rb in ~/scripts/ and run chmod a+x ~/scripts/getremotetabs.rb. You need to edit the remote_host variable in this script on each machine to match the hostname you set up in your ~/.ssh/config file for the 'other' Mac.

#!/usr/bin/ruby
# retrieves a list of urls from the front Safari window running on a remote machine

remote_host = 'air' # as set up in ~/.ssh/config with nick and keyless login

%x{ssh #{remote_host} ~/scripts/remotetabs.rb}.chomp.split(' ').each { |url|
  %x{osascript -e 'tell application "Safari" to open location "#{url}"'}
}

That's it. You can save an AppleScript with do shell script "/Users/username/scripts/getremotetabs.rb" anywhere you want to, or just call the script from the command line. Also, stop making fun of my OSD. I mean it.

Related posts:

1. Saving Safari browsing sessions to Evernote
2. Save Safari tabs to Instapaper
3. Geeklet: 1-minute average CPU load

Originally posted on BrettTerpstra.com at Duplicating Safari browsing sessions between Macs

You can download ready-to-go versions of the workflows covered in this post here: GrabIconWorkflows.zip.

If you want to customize these workflows, you’ll need to know a little bit about the inner Bash workings, but nothing an up-and-coming nerd can’t figure out. To get started, open up Automator.app and create a new file with the “Application” preset.

A basic workflow

We’ll start with a really simple Automator application that you can drop an application onto to extract its icon at 512px and save it as a JPEG to the Desktop. One step, no interaction.

In your new Automator workflow, find “Run Shell Script” in the Library on the left. You can use the filter at the top to quickly narrow down the choices. Drag the action into your workflow editor on the right, and paste the following code into it:

APPDIR=$1
ICON=`defaults read "$APPDIR/Contents/Info" CFBundleIconFile|sed -e 's/\.icns$//'`
ICONFILE="$APPDIR/Contents/Resources/$ICON.icns"
APPNAME=`basename "$APPDIR" .app`
OUTFILE="$HOME/Desktop/${APPNAME}_icon.jpg"
/usr/bin/sips -s format jpeg --resampleHeightWidthMax 512 "$ICONFILE" --out "$OUTFILE"

Make sure the shell is set to “/bin/bash” and change “Pass input” to “as arguments”. Save the workflow. You’ll probably want to name it something creative and put it somewhere useful, such as ~/Applications/512Desktop.app. I have the utmost faith that you’ll come up with something brilliant. Here’s what your workflow should look like:

Now, you can just drop an application onto the icon for 512Desktop.app and the extracted icon will show up on your Desktop, named based on the name of the application you dropped on the workflow, with “_icon.jpg” appended to it. That was easy, right?

A complete workflow with user interaction

To make something more universally useful, we’ll create a workflow that asks the user where to save it. This time, we’ll output a PNG file and use the maximum available icon size. We covered how to do both of these in the last post, so I won’t go into all of the details in this one. Page back if you’re curious (or confused).

We’ll also need to store variables and pass multiple arguments to shell scripts in the workflow to pull this off. This is the stuff that makes Automator both awesome and frustrating, but once you get the hang of it, new possibilities open up. In this example it may seem like a lot of work just to ask a user where to save a file, but the concept allows you to get user input (without using AppleScript) in shell scripts. It’s worth knowing.

Create a new Automator application, just like above. Since this is going to be a droplet, the path of the Application will be passed to the first action when you run it (by dragging an app onto it). We need to store that as a variable for later, and then pass it on to the first shell script. To do so, drag the “Set Value of Variable” action from the library into your workflow. Click the dropdown for “Variable:” and choose “New variable”. Title the variable “appname”.

Next, drag the “Run Shell Script” action in after the variable action. Paste the following code into it:

ICON=`defaults read "$1/Contents/Info" CFBundleIconFile|sed -e 's/\.icns$//'`
echo "$1/Contents/Resources/$ICON.icns"

This gets the icon file’s name and hands it back to Automator. We’ve got the application name and location, as well as the name and path of the icon file we need. We just need to know where the user wants to save it to. Add the “Ask for Finder Items” action in next, and set the prompt to “Save to:”. “Start at:” should be set to Desktop by default, but you can modify that to open the dialog to whatever directory makes sense for you. Change “Type:” to “Folders” and make sure that “Allow Multiple Section” is unchecked.

Now we need our appname variable back, so drag “Get Value of Variable” in as the next action. Set “Variable:” to “appname” (which will be available in the dropdown). The outputs of each command stack up, so now we have the icon file path, the user’s destination selection and the Application’s name (appname) all ready to pass to the final shell script as arguments ($1 $2 $3).

Drag in a “Run Shell Script” action as the last command. Again, set it to “/bin/bash” and pass input as arguments. Then, paste this code into it:

APPNAME=`basename "$3" .app`
OUTFILE="$2/${APPNAME}_icon.png"
MAX=`sips -g pixelWidth "$1"|tail -1|awk '{print $2}'`
/usr/bin/sips -s format png --resampleHeightWidthMax $MAX "$1" --out "$OUTFILE"

Here’s what it should look like now:

Done. Save the workflow to a file such as ~/Applications/SaveMaxIcon.app. Try dragging an application directly onto it. You’ll be asked to choose a folder. Click “OK” and the resulting icon image file will show up in the selected location. You can stick this app on your Desktop (or alias it there) for easy access, add it to your Finder sidebar or even drag it into the toolbar of a Finder window.

If you want to choose an app from a dialog instead, you can insert an “Ask for Finder Items” action at the beginning of the workflow. Set “Start at:” to “/Applications”, “Type:” to “Files” and uncheck “Allow Multiple Selections”. Running the workflow will pop up a file dialog asking you to select an application manually before requesting the destination and running the rest of the script. This might be faster than finding, dragging and dropping, in some cases.

Bonus tip: you can incorporate Automator workflows into shell scripts (and AppleScripts using do shell script) with the automator command line utility. You can call it directly on a workflow (automator nameof.workflow) or pass input to it using the –i parameter. The most practical application I can think of in this case would be to create an AppleScript application bundle containing both on run and on open handlers and both versions of the above workflow embedded in it. Then you could create a single application that would act on dropped files or offer a dialog if it was run directly. There’s probably an easier way to do that, though.

Grab copies of the workflows to get started (GrabIconWorkflows.zip), and I’d love to hear if you come up with other uses for them. That’s a wrap, hope it gave you some ideas for your own nerdery.

Related posts:

1. Grabbing a Mac app’s icon: building blocks
2. Grabbing a Mac app’s icon: advanced Bash usage
3. Dropbox and seamless mutli-Mac computing?

Originally posted on BrettTerpstra.com at Grabbing a Mac app’s icon: Automator style

• Logic to locate the app if it exists outside of /Applications
• A check using sips to find the maximum available image size
• Allow user input to set the final output size
• Allow the user to decide whether to open the result in Preview.app

We’ll also look at a very, very cool trick for adding tab-completion for application names to the open -a command, as well as our geticon() function. Yes, it’s that nerdy.

In the next post, we’ll use Automator to make this into a droplet we can drag apps onto from Finder. If you don’t give a flying fire truck about Terminal, you can skip straight there and create something useful without touching the command line. This one’s for the nerds (and wannabe nerds).### A for loop directory search ###

We’ll use a bash for loop to search some predefined locations. You could also use mdfind¹ to let Spotlight locate the app, but we’ll keep it simple for now. I’ve set it up to look in some standard locations for the file:

APPDIR=''
 for dir in "/Applications/" "/Applications/Utilities/" "/Developer/Applications/" "/Developer/Applications/Utilties/"; do
   if [[ -d ${dir}$APP.app ]]; then 
       APPDIR=$dir
       break
   fi
 done

$APPDIR is now set to the location that $APP was found, or to ” (blank) if it wasn’t found in any of the specified folders. We can check for that in the next part and fail gracefully if we didn’t find the specified app.

Getting the maximum image size

Modern Mac icons generally have a pixel width of 512 or greater, but some legacy applications’ icons are 256px or smaller. Finding the maximum pixel width of the image allows us to avoid creating a distorted image as a result of sizing up beyond the largest image in the .icns file. The sips command can do this with a little help from awk² to clean up the output. The following command gets the pixelWidth property from the icon file, grabs the last line of output and removes extraneous text to leave us with just a number:

MAXAVAIL=`sips -g pixelWidth "${APPDIR}$APP.app/Contents/Resources/$ICON.icns"|tail -1|awk '{print $2}'`

We could use the number we found to output a file with the maximum dimensions, but since we’re making a general-purpose function, we’ll ask the user what they want.

Getting user input

There are a few ways to offer options in Bash. This is the simplest route I know. It doesn’t innately allow for a lot of error checking; the user could enter letters instead of numbers or an unattainable dimension, for example. We’ll add some basic checks, but we’ll assume that you can properly enter a number when asked. You’re smart like that.

echo -n "Enter max pixel width ($MAXAVAIL): "
read MAX
if [[ $MAX == '' || $MAX -gt $MAXAVAIL ]]; then
  MAX=$MAXAVAIL
fi

We echo the prompt (the –n keeps it from echoing a newline), and we use our previously determined $MAXAVAIL variable to set a cap. If the user’s answer is empty or larger than $MAXAVAIL, we default to $MAXAVAIL.

The whole shebang

Here’s a complete Bash function that you can paste at the end of your ~/.bash_profile. It offers to open the resulting image in Preview.app, but you can easily modify that to whatever app makes sense in your workflow.

function geticon() {
  APP=`echo $1|sed -e 's/\.app$//'`
  APPDIR=''
  for dir in "/Applications/" "/Applications/Utilities/" "/Developer/Applications/" "/Developer/Applications/Utilties/"; do
    if [[ -d ${dir}$APP.app ]]; then 
        APPDIR=$dir
        break
    fi
  done
  if [[ $APPDIR == '' ]]; then
    echo "App not found"
  else
    ICON=`defaults read "${APPDIR}$APP.app/Contents/Info" CFBundleIconFile|sed -e 's/\.icns$//'`
    OUTFILE="$HOME/Desktop/${APP}_icon.jpg"
    MAXAVAIL=`sips -g pixelWidth "${APPDIR}$APP.app/Contents/Resources/$ICON.icns"|tail -1|awk '{print $2}'`
    echo -n "Enter max pixel width ($MAXAVAIL): "
  	read MAX
  	if [[ $MAX == '' || $MAX -gt $MAXAVAIL ]]; then
  	  MAX=$MAXAVAIL
  	fi
    /usr/bin/sips -s format jpeg --resampleHeightWidthMax $MAX "${APPDIR}$APP.app/Contents/Resources/$ICON.icns" --out "$OUTFILE" > /dev/null 2>&1
    echo "Wrote JPEG to $OUTFILE."
  	echo -n 'Open in Preview? (y/N): '
  	read ANSWER
  	if [[ $ANSWER == 'y' ]]; then
  	  open -a "Preview.app" "$OUTFILE"
  	fi
  fi
}

Extra credit: tab completion for app names

Before we get into making this into a GUI using Automator, wouldn’t it be cool if you could autocomplete an app name from the command line when you use this? This is where you find out that I can nerd anything to death, but let’s do it.

First, we need some functions to build a list of all of our available applications and provide them to Bash’s completion command. I’m modifying a script from Kim Holburn for this, updated to work on 10.6 and provide case-insensitive completion. Just put the file in your user’s home directory for now. When we’re done, it will also provide application name tab completion for open -a (and o if you alias o=“open –a” in your .bash_profile). Click the link below to open the script, then save it to your home folder as “.app_completions”.

Download .app_completions

Once you have that file located in ~/.app_completions, we just need to reference it in .bash_profile and add a few settings. Put this near the top of ~/.bash_profile:

source ~/.app_completions
bind "set completion-ignore-case on"
set show-all-if-ambiguous on
alias o="open -a"

At the command line, run source ~/.bash_profile. Now, assuming you’ve also added the previous geticon function to .bash_profile, you should be able to type geticon term and hit tab right after the ‘m’ to have it complete to “Terminal.app” automatically. This makes it a lot easier to get the app’s name, spacing and capitalization exactly right. You’ve also aliased “o” to launch an app in the process. Type o auto to complete to “Automator.app” and launch it.

We’ll dig into Automator next and turn this whole thing into something pretty.

Related posts:

1. Grabbing a Mac app’s icon: Automator style
2. Grabbing a Mac app’s icon: building blocks
3. Mac App Giveaway: TextExpander

Originally posted on BrettTerpstra.com at Grabbing a Mac app’s icon: advanced Bash usage

My solution ended up having some tricks in it that I thought were worth sharing, so I’m going to write it up here. This is the first post in a three-part series; an epic tribute to obsessive nerdery. It will probably eventually be summarized into the how-to section, but this is the ever-so-informative longhand version.

Introduction/excusatory verbage

I use application icons quite a bit in my writing for TUAW, so having a quick way to do this is worthwhile. You may never need an application icon as a ready-to-post JPEG, but it’s worthwhile to know tricks such as how to grab, resize and convert images from the command line or how to build an Automator action which combines Finder dialogs, shell scripts and Automator variables.

I’ll start with the basic Terminal commands to lay a foundation.

Finding an app’s icon with the defaults command

On a Mac, every application is actually a folder, referred to as a “bundle”. Within that folder are libraries, executables and resources (like images and icons). There’s also an important file called Info.plist which stores information like the application’s name, identifiers, file types and–most relevant right now–the name of the file containing the application’s icon. The application icon is an an .icns file, stored in AppName.app/Contents/Resources. Its title does not have to be the same as the app’s, so–before we can extract and convert it–we need to get its actual filename from Info.plist.

Info.plist is stored as an XML file (as opposed to a binary plist). As such, we could grep for the filename and run a bunch of Unix commands to parse out the filename, but there’s an easier and more reliable way to do it using the defaults² command built into OS X. defaults reads plist files and can output the value of specific keys. The key we want is CFBundleIconFile, which holds the icon’s filename. We’ll assume that we’ve already retrieved the name of the app and stored it in a variable called $APP. Here’s what you would run on the command line:

defaults read "/Applications/$APP.app/Contents/Info" CFBundleIconFile

The response may or may not have a file extension (.icns). We want to trim the extension if it exists so that we have a clean foundation to build on. You can do this with several different Unix utilities, including basic bash substitution; we’ll stick with sed³ for now. We pipe (|) the output of the defaults command into sed, and remove “.icns” if it exists:

defaults read "/Applications/$APP.app/Contents/Info" CFBundleIconFile|sed -e 's/\.icns$//'

Converting the icon file to an image format

The .icns format holds multiple versions of the icon, and doesn’t do us much good if we want an image file for the web. Fortunately, the built-in command sips can do some neat tricks with it, including converting it to various formats⁴. We know what the icon file is titled now, and we know where to look for it. We just build a sips command to read it, convert it and output the result.

The -s format parameter sets an output format in sips. This can be one of many formats, but we’ll use the JPEG format for this example. This will compress the result to a web jpeg with a solid, white background. Using the PNG format instead would preserve the transparency, so if you need to do other image manipulation, you can substitute “png” for “jpeg”.

Let’s use the $APP variable we’ve created to set a default output filename on the Desktop. For now, we’re assuming the app exists in the standard /Applications folder (I’ll show a more complex workflow for locating the app in a bit). We’re also assuming that we’ve stored the result of the above defaults command in $ICON.

OUTFILE="$HOME/Desktop/${APP}_icon.jpg"
sips -s format jpeg "/Applications/$APP.app/Contents/Resources/$ICON.icns" --out $OUTFILE

Now we have the basic pieces we can use to build a script to automate this from the command line. Here’s an example which expects the application name as the only argument, properly cased:

#!/bin/bash
 
APP=`echo $1|sed -e 's/\.app$//'`
# Removes ".app" if it was passed
 
ICON=`defaults read /Applications/$APP.app/Contents/Info CFBundleIconFile|sed -e 's/\.icns$//'`
# Removes ".icns" if the Info.plist value includes it
# Harcoded for /Applications, needs to be rewritten for other locations or droplets
 
## Save icon on Desktop in JPEG format, resized to 256 max width/height
OUTFILE="$HOME/Desktop/${APP}_icon.jpg"
/usr/bin/sips -s format jpeg "/Applications/$APP.app/Contents/Resources/$ICON.icns" --out $OUTFILE

Extra credit: image optimization

Since we’re automating, we can add a final step to the script to handle whatever steps we would normally take next. For example, we could open it in Skitch for quick resizing, or in Acorn for more complex manipulation. If we saved a JPEG to a size we already know is correct for our purposes, we could open it straight in an optimizer such as ImageOptim to quickly improve the compression. We could also make use of a command line utility like ImageMagick, jpegtran or pngcrush, all of which require some installation and extra work. If you have them, great, if not, that’s an article for another time.

For the record, Skitch saves horribly large JPEGs, whereas Acorn saves amazingly well-compressed images. If you resize with Skitch, you’ll want to compress it with something else as well.

Assuming we’re using an application and not a CLI utility, we can use the open command to send the resulting file to the app. We can also avoid some confusion by initially saving the converted icon file to a default temporary directory and then opening it from there. Here’s a revised script that does that, then opens the final image in Acorn for quick resizing and saving to any location. We’ll use the PNG format to preserve the original transparency, and you can substitute any graphics application for Acorn:

#!/bin/bash
 
APP=`echo $1|sed -e 's/\.app$//'`
# Removes ".app" if it was passed
 
ICON=`defaults read /Applications/$APP.app/Contents/Info CFBundleIconFile|sed -e 's/\.icns$//'`
# Removes ".icns" if the Info.plist has it
# Harcoded for /Applications, needs to be rewritten for other locations or droplets
 
## Output file to a temp directory (TMPDIR) as a PNG and open in Acorn for resizing and conversion
 
OUTFILE="$TMPDIR${APP}_icon.png"
sips -s format png "/Applications/$APP.app/Contents/Resources/$ICON.icns" --out $OUTFILE
open -a "Acorn.app" $OUTFILE

I think you get the idea. You can take this script and easily adjust the output format and destination application. In the next post, we’ll cover making this into a fully customized Bash function, with some extra goodies.

Related posts:

1. Grabbing a Mac app’s icon: Automator style
2. Grabbing a Mac app’s icon: advanced Bash usage
3. Bored with your MacVim icon? Me too.

Originally posted on BrettTerpstra.com at Grabbing a Mac app’s icon: building blocks