As often noted, in order to set up the ability to monitor traced outputs to disk from the flash player, one must:
1. Install the debugger version of the flash player.
2. Create the default named file to which the logging will be sent at (on mac anyway) ~/Library/Preferences/Macromedia/Flash\ Player/Logs/flashlog.txt. You can query online for the proper location for Linux and Windows.
3. On mac, create the mm.cfg file in /Library/Application\ Support/Macromedia
4. Add these lines to the mm.cfg file:
     ErrorReportingEnable=1
     TraceOutputFileEnable=1
5. Restart you machine.

In some cases, however, this does not actually work — that is, nothing gets written to the file, and there is no error to look for. I figured it might be permissions, so changing the permissions for flashlog.txt to 660 (sudo chmod 660 flashlog.txt) fixed the issue. Note that group needs to be set to be readable/writable. After doing a search for the issue online with “chmod” in the search terms, I also found a reference noting that the mm.cfg file needed to have its permissions changed to 755, but I don’t think that is probably necessary. It wasn’t for me.

Recently I wanted an easy way to generate diffs from svn that I could easily read — i.e. with some sort of markup. TextMate automatically displays diffs in an attractive manner, and in a manner that makes them much easier to decipher visually. It also allows you to export any code file as html, which is also nice; however, I didn’t want to keep having to open all my diffs in TextMate just for the sake of formatting them. I also wanted to be able to generate them quickly and be able to distribute them as standalone files that could ostensibly be viewed in a web browser.

I did a little research and found a script over at http://www.linuxjournal.com/content/convert-diff-output-colorized-html which was fairly close to what I wanted to do, so I started with that and modified its processing algorithm and css styling to match my TextMate output. After getting that working with static svn diff output files, I added the ability to simply navigate to the desired directory in the command line and invoke the script to output the html formatted diff.

At that point, I decided that there were 2 key comparisons that were important to me generally — svn diff -r HEAD and svn diff -r PREV:HEAD — which output the diff for the local file to the repository version, and the diff for the head as compared to the previous revision. In other words, one compares the stuff on your machine to the repository, and the other can compare what you just committed to what was there before. I added those, and a help command, and that become svndiff2html. I hope this helps someone save some time. Code follows after the break…

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 

#!/bin/bash

# svndiff2html runs svn diff on the current directory path and outputs a
# formatted HTML file to provide easier legibility.

diff="";
out="";
html="";
args="";

# ******************************************************************************
# FUNCTIONS
# ******************************************************************************

function displayHelp
{
	echo "     ";
	echo "diff2html -- outputs an html encoded diff file for the current svn repo.";
	echo "     ";
	echo "USAGE:";
	echo "     diff2html [-local or -l] outputPath";
	echo "     ";
	echo "PARAMETERS:"
	echo "     -local (optional)"
	echo "     This parameter tells diff2html to make the comparison between "
	echo "     the local file changes and the current state of the svn repository.";
	echo "     If -local is not present, the script will compare the most recent ";
	echo "     commit to the repository with the repo version previous to it.";
	echo "     ";
	echo "     outputPath";
	echo "     This is simply the output path for the html file that is generated";
	echo "     by the script.";
	echo "     ";
	echo "To use, add to PATH, chmod to 755, navigate to folder of svn files";
	echo "that are to be diff'ed, and run diff2html. (diff2html must be run within";
	echo "the directory of the files to be diffed.)";
}

function pipeout
{
	# echo -n "$1";
	echo -n "$1" >> $out;
}

# ******************************************************************************


# Parse the parameters
if [[ "$1" == "-h" || "$1" == "-help" || "$1" == "help" ]]; then
	displayHelp;
	exit;
elif [[ "$1" == "-local" || "$1" == "-l" ]]; then
	# for comparing local to repo
	args="HEAD";
	# diff=`svn diff --no-diff-deleted -x "-u -b -w --ignore-eol-style" -r HEAD`;
	out="$2";
else
	# for comparing the most recent commit to the one previous
	args="PREV:HEAD";
	# diff=`svn diff --no-diff-deleted -x "-u -b -w --ignore-eol-style" -r PREV:HEAD`;
	out="$1";
fi

# Error if not enough parameters have been entered
if [ "$out" == "" ]; then
	echo;
	echo "ERROR! *************************************";
	echo "You must at least enter an output file path.";
	echo "Enter 'diff2html help' for usage."
	echo;
	exit;
fi

echo;
if [ "$args" == "HEAD" ]; then
	echo "NOTE: Keep in mind files not 'added' to source control will not be ";
	echo "included in the diff. Please first 'add' those files to run local diff ";
	echo "on them. (These files with be displayed in their entirety.)";
	echo;
	echo "Sending local diff to: $out";
else
	echo "Sending head to previous diff to: $out";
fi


echo "" > $out;

# Send the header of the html file to the output file
pipeout "
<html>
<head>
<title>Diff for $PWD</title>
</head>
        <style media=\"screen\" type=\"text/css\">

body {
	margin: 0;
	padding: 0;
	background-color: #000000;
}

pre {
	color: #F8F8F8;
	background-color: #0B161D;

	margin: 0;
	padding: 0 0 0 2px;
	font-family: PanicSans, monospace;
	font-size: 12px;
	line-height: 1.3em;
	word-wrap: break-word;
	white-space: pre;
	white-space: pre-wrap;
	white-space: -moz-pre-wrap;
	white-space: -o-pre-wrap;


   padding-top: 0.2em;
   padding-bottom: 0.1em;
}

pre span {
   padding-top: 0.2em;
   padding-bottom: 0.1em;
}

/* Comment */
pre .comment {
	color: #F8F8F8;
	font-style: italic;
	background-color: #0B161D;
}
/* diff.header */
pre.textmate-source.plasticcodewrap .meta_diff, pre.textmate-source.plasticcodewrap .meta_diff_header {
	color: #F8F8F8;
	font-style: italic;
	background-color: #0E2231;
}

/* diff.header */
pre .at2 {
	color: #F8F8F8;
	font-style: italic;
	font-weight: bold;
	background-color: #0B161D;
}

/* diff.deleted */
pre .minus {
	color: #F8F8F8;
	background-color: #D03620;
}
/* diff.inserted */
pre .plus {
	color: #F8F8F8;
	background-color: #41A83E;
}

pre span .index   {
    background-color: #0E2231;
}

pre span .index:before {
/*    content:\"<div></div>\";*/
}

.break {
    padding-top:15px;
}

.headerDivider {
    background-color: #0E2231;
    padding-bottom: 4px;
}

pre .minus3   {
	font-weight: bold;
	background-color: #280A06; /*#0B161D;*/
}
pre .plus3 {
	font-weight: bold;
	background-color: #0B230E; /*#0B161D;*/
}
pre .only     { color: purple;                   }
pre .diff     { color: #8A2BE2;                    }


/* diff.changed */
pre.textmate-source.plasticcodewrap .markup_changed {
	color: #F8F8F8;
	background-color: #C4B14A;
}
</style>
<body>
<pre>
<span class=\"comment\">
========= DIFFS =========";

echo -n ''


first=1
diffseen=0
lastonly=0
folderPropertiesSkipped=0

OIFS=$IFS
IFS='
'

# Pipe out the svn diff to our processing loop to add html tags
svn diff --no-diff-deleted -x "-u -b -w --ignore-eol-style" -r $args | while read -r s
do
	# echo "$line";

    # Get beginning of line to determine what type
    # of diff line it is.
    t1=${s:0:1}
    t2=${s:0:2}
    t3=${s:0:3}
    t4=${s:0:4}
    t6=${s:0:6}
    t7=${s:0:7}

    # Determine HTML class to use.
    if [[ "$t7" == 'Only in' ]]; then
        cls='only'
        if [[ $diffseen -eq 0 ]]; then
            diffseen=1
            if [ $folderPropertiesSkipped -eq 1 ]; then
				echo -n '</span>' >> $out;
			fi
        else
            if [[ $lastonly -eq 0 ]]; then
                if [ $folderPropertiesSkipped -eq 1 ]; then
					echo "</div>" >> $out;
				fi
            fi
        fi
        if [[ $lastonly -eq 0 ]]; then
            if [ $folderPropertiesSkipped -eq 1 ]; then
				echo "<div class='diffdiv'>" >> $out;
			fi
        fi
        lastonly=1
    elif [[ "$t4" == 'diff' ]]; then
        cls='diff'
        if [[ $diffseen -eq 0 ]]; then
            diffseen=1
            if [ $folderPropertiesSkipped -eq 1 ]; then
				echo -n '</span>' >> $out;
			fi
        else
            if [ $folderPropertiesSkipped -eq 1 ]; then
				echo "</div>" >> $out;
			fi
        fi
        if [ $folderPropertiesSkipped -eq 1 ]; then
			echo "<div class='diffdiv'>" >> $out;
		fi
        lastonly=0
    elif  [[ "$t3" == '+++'  ]]; then
        cls='plus3'
        lastonly=0
    elif  [[ "$t6" == 'Index:'  ]]; then
        cls='index'
        lastonly=0
		folderPropertiesSkipped=1
    elif  [[ "$t6" == '======'  ]]; then
        cls='headerDivider'
        lastonly=0
    elif  [[ "$t3" == '---'  ]]; then
        cls='minus3'
        lastonly=0
    elif  [[ "$t2" == '@@'   ]]; then
        cls='at2'
        lastonly=0
    elif  [[ "$t1" == '+'    ]]; then
        cls='plus'
        lastonly=0
    elif  [[ "$t1" == '-'    ]]; then
        cls='minus'
        lastonly=0
    else
        cls=
        lastonly=0
    fi

    # Convert &, <, > to HTML entities.
    s=$(sed -e 's/\&/\&amp;/g' -e 's/</\&lt;/g' -e 's/>/\&gt;/g' <<<"$s")
    if [[ $first -eq 1 ]]; then
        first=0
    else
        if [ $folderPropertiesSkipped -eq 1 ]; then
			echo >> $out;
		fi
    fi

    # Output the line.
	if [ $folderPropertiesSkipped -eq 1 ]; then
	    if [ "$cls" == "index" ]; then
	        echo -n '<div class="break"><span> </span></div><span class="'${cls}'">'${s}'</span>' >> $out;
	    elif [ "$cls" == "headerDivider" ]; then
	        echo -n '<div class="headerDivider"><span class="index">'${s}'</span></div>' >> $out;
	    elif [ "$cls" == "at2" ]; then
	        echo -n '<div style="padding-top:2px"><span> </span></div><span class="'${cls}'">'${s}'</span>' >> $out;
	    elif [[ "$cls" ]]; then
	        echo -n '<span class="'${cls}'">'${s}'</span>' >> $out;
	    else
	        echo -n ${s} >> $out;
	    fi
	fi

done

IFS=$OIFS

if [[ $diffseen -eq 0  &&  $onlyseen -eq 0 ]]; then
    echo -n '</span>' >> $out;
else
    echo "</div>" >> $out;
fi
echo >> $out;


# Add the footer to the output file
pipeout "


========= END OF DIFFS =========
</span>
</pre>
</body>
</html>
";

echo "HTML diff complete.";

Posted by way of Plains of the Plastic Intafon

This is somewhat trivial though not entirely intuitive — passing flashvars from an embedded flash movie to a flash movie that the swf is loading. I was working on some code recently that accomplished this task using one solution that I have seen most often — by passing the flashvars as query string parameters. In other words:

SwfA.swf is embedded on the page and has the flash var “userName” with the value “Voytek”. SwfB.swf is loaded by SwfA.swf, and must utilize the userName variable. Often this will be accomplished by loading SwfB using the URL “SwfB.swf?userName=Voytek”. This works just fine for most cases. There are, however some cases where this can be problematic. For example, suppose the site this is to be deployed on is a high traffic site and a caching system is employed to cache the swf files. Depending on the caching server, it may be that files are cached according to their *full* URL, which means that if we now need to load the swf with the userName “Milgrim”, we have cached the file a second time referenced by the URL “SwfB.swf?userName=Milgrim”. Now deploy this on a site with hundreds of thousands of users, and you might as well not even cache the swf files at all.

Fortunately, it came to my attention that the loaded swf SwfB can access the flashVars just as easily as SwfA, it just so happens that that action of getting the flashVars needs to be made asynchronously. As long as the loaded swf SwfB has already been added to the stage, it can access the flashVars via “stage.loaderInfo.parameters” (rather than accessing the flashVars in the embedded SwfA using “root.loaderInfo.parameters”). In order for this to be possible however, SwfB must be loaded and added to the display list of the stage.

package
{	
	import flash.display.Sprite;
	import flash.display.Loader;
	import flash.net.URLRequest;

	/** 
	 * Loads SwfB in the same way a swf usually loads a swf. 
	 */
	public class SwfA extends Sprite
	{
		public function SwfA()
		{
			var flashVars:Object = root.loaderInfo.parameters;
			var s:String = this + "\n";
			for (var i:String in flashVars) {
				s += i + " = " + flashVars[i] + "\n";
			}
			trace("Main Client FlashVars:" + s);
			
			var ldr:Loader = new Loader();
			var urlReq:URLRequest = new URLRequest("SwfB.swf");
			ldr.load(urlReq);
			addChild(ldr);
		}
	}
}


package
{
	import flash.display.Sprite;
	import flash.events.Event;
	
	/**
	 * This class is loaded by SwfA and waits until it has been added to the stage
	 * in order to obtain the flash vars from the stage.loaderInfo.
	 */
	public class SwfB extends Sprite
	{
		public function SwfB()
		{
			addEventListener(Event.ADDED_TO_STAGE, onAddedToStage);
		}
		
		private function onAddedToStage(e:Event):void
		{
			var flashVars:Object = stage.loaderInfo.parameters;
			var s:String = this + "\n";
			for (var i:String in flashVars) {
				s += i + " = " + flashVars[i] + "\n";
			}
			trace("Loaded Swf FlashVars when Added to Stage: " + s);
		}
	}
}

As you can see from the code above, SwfA just loads SwfB just like you would normally do. SwfB just listens for its own ADDED_TO_STAGE event and then grabs the flashVars from the stage’s loaderInfo. The only catch is that if the UI build or some other immediate process depends on the flashVars, then you need to make sure and wait for the ADDED_TO_STAGE event in order to proceed.

Posted by way of micro-plains

Tip for the day: If trace() is not working in Flash Builder debug mode, try quitting Flash Builder and all browsers and delete the mm.cfg file. For some reason this fixed the issue for me…

Posted via email from micro-plains

Today I was attempting to run a grep search on all the *.as files in the project code I am working with. The code in places is both old and new and has been edited in a variety of editors, from the Flash IDE, to TextMate, to Flash Builder, to who knows how else. The unfortunate result of this history is that many of the files have Mac style line endings (\r) instead of Unix style line endings (\n). When trying to run a grep search on these files, the search returns a bunch of jumbled code salad.

Since I was only really wanting to do the search for now, I ended up using:

tr '\r' '\n' <filename.txt | grep searchstring

This works by using the transform command to convert the mac line endings, and pipe out the result to a grep search that is now happy. For more permanent results, the line endings could be replaced entirely using:

perl -pi -e 's/\r/\n/g' textfile.txt

The “tr” command, however, was a great temporary work around for running the search on the files that I needed to run, since I didn’t want to end up having to recommit a bunch of files to SVN just to change the line-endings. The original jumbled search result I was getting was somewhat inexplicable until I started analyzing the reason why it worked for some files and not for others. Hope this helps someone out there.

Posted via email from micro-plains

Something I suppose I had never really tested thoroughly before having not had to deal too much with random application embeds in the wild is the issue with ExternalInterface.available not quite doing what you might expect. According to Adobe documentation, this property

Indicates whether this player is in a container that offers an external interface. If the external interface is available, this property is true; otherwise, it is false.

This is usually fine, as long as your embed has allowScriptAccess defined to either “always” or “sameDomain” (when the embed lives on the same domain as the swf). In addition, when prescribing embed code for folks to use, one would normally provide the embed code with allowScriptAccess set to “always” if there was a need to use ExternalInterface. Unfortunately, the ExternalInterface.available property will return true in cases where the allowScriptAccess parameter is not set to allow access (such as on Facebook flash embeds, where it is always rewritten to “never”) or when an industrious embedder has removed all the seemingly extraneous parameters from the embed.

The solution for this scenario is to always use a try-catch statement to trap any errors that occur when trying to access the ExternalInterface, and deal with the error accordingly. This might look something like:

    if (ExternalInterface.available) {
        try {
            ExternalInterface.addCallback(“moo”, onMoo);
        } catch (error:SecurityError) {
            trace(“Error: ” + error.toString());
        }
    } else {
        trace(“ExternalInterface is not available for this container.”);
    }

This is not super pretty, but this will ensure that the app doesn’t generate any unexpected behavior in the wild.

Posted via email from micro-plains

via blog.six4rty.ch

I like the article at http://blog.six4rty.ch/2010/07/31/as3-multiline-textfields-and-line-metrics/, mainly because of this graphic. I found it somewhere before long ago (maybe the same place) — it is a big help when dealing with customized text layout situations in flash where you have to do manual baseline aligment and such.

Posted via email from micro-plains

via flickr.com

I’ve been playing around with the MoreLomo app for iPhone…in lieu of getting a Harenezumi…

Posted via email from Intafonetic

Posted via email from Intafonerous

package {

	import fl.controls.TextInput;
	import fl.managers.IFocusManagerComponent;

	/**
	 * Extends the TextInput component in order to set the default width and
	 * height, and sets the focusRectPadding to 0 (so the focus rectangle lies
	 * directly on top of the grey text input border skin.
	 */
	public class TextInput2 extends TextInput implements IFocusManagerComponent {

		/**
		 * @constructor
		 */
		public function TextInput2() {
			super();
			textField.width = 1;
			textField.height = 1;
			width = 64;
			height = 18;
			setStyle("focusRectPadding", 0);
		}

		/**
		 * The UIComponent class, when the component is in focus, creates the
		 * uiFocusRect and sets it at childIndex 0. Unfortunately, the text input
		 * skin is then above the focus rect, and so the focus rect disappears
		 * when the focusRectPadding is 0. This calls the parent implementation,
		 * then ensures that the focus rect is visible by changing its
		 * child index.
		 */
		override public function drawFocus(draw:Boolean):void {
			super.drawFocus(draw);

			if (uiFocusRect != null) {
				setChildIndex(uiFocusRect, numChildren - 1);
			}
		}
	}
}

UPDATE: I updated the above script to set the size of the TextField in the TextInput component to be 1×1. This also fixes the problem that the TextField is created as 100×100 pixels when it is first created (as are all dynamically generated text fields). This matters if you wish to use any customized layout (such as the Yahoo astra layout managers), and don’t want to have to call drawNow() or wait a frame to finalize layout settings in a UI.

Regardless of whether or not a shape, such as a rectangle, is drawn in Flash with a hairline border line, or a borderline of 1, the result on an unscaled shape is essentially the same. The crisp outline of the shape is drawn with a pixel width of 1. The downside of this occurs when trying to create pixel perfect UI’s, and especially those using shapes with a scalenine grid assigned to them.

Using the AS3 drawing API, you can create a rectangle that has a lineStyle with a width of 1, and some fill, which would look something like this:

var sh:Shape = new Shape();
sh.graphics.lineStyle(1, 0xFF0000);
sh.graphics.beginFill(0xFF6600);
sh.graphics.drawRect(0, 0, 100, 100);
sh.graphics.endFill();
addChild(sh);
trace("Size: " + sh.width + " x " + sh.height);

The code above so draws an orange rectangle with a red border that is 201 pixels wide and 101 pixels tall. If you don’t know why, the reason is because flash draws the line on the pixel width and height of the rectangle with a line size of 1. This makes your shape 201 x 101; thankfully, Flash will report the width and height correctly as 201 x 101.

This gets stickier if you have a shape that is used as a component skin, and has a scale9Grid applied to it. In this case you will likely be working with a component that you expect to take up 200×100 pixels on the stage when you tell it to be that size. However, if the skin used features “line” outlines at its borders, your component will get drawn on the stage with extra pixels. If you dig into the Flash component skins, you will notice that most of the skins use fills for any borders on the shapes (even 1 pixel wide borders) so that the scale9Grid enabled shapes will scale correctly to the pixel. That being said, the proper way to draw the simple skin shape in this case, programmatically, would be:

var sh2:Shape = new Shape();
sh2.graphics.beginFill(0xFF0000);
sh2.graphics.drawRect(0, 0, 200, 100);
sh2.graphics.beginFill(0xFF6600);
sh2.graphics.drawRect(1, 1, 198, 98);
sh2.graphics.endFill();
addChild(sh2);
trace("Size: " + sh2.width + " x " + sh2.height);

Incidentally, this also often cleans up some anti-aliasing at the corners of rectangular shapes which I believe is cause by some weirdness in the way the “caps” are drawn on the shapes. (but don’t quote me on that…)

Flash 9 LiveDocs:  qss-http://www.google.com/search?&btnI&q=site%3Ahttp%3A%2F%2Flivedocs.adobe.com%2Fflash%2F9.0%2FActionScriptLangRefV3%2F+***

Flash 10 Help Docs:  qss-http://www.google.com/search?&btnI&q=site%3Ahttp%3A%2F%2Fhelp.adobe.com%2Fen_US%2FAS3LCR%2FFlash_10.0%2F+***

Basically, since there is no convenient way I found to use the search mechanisms on the Adobe site, these queries are running a google lucky search on the wildcard applied search term, while restricting the search to the site pertinent to the docs of interest. Running the assigned key command will trigger the Quicksilver text entry box; simply enter the term, such as “vector” for Flash 10, and the google lucky search will be performed. Since the lucky search is restricted to the livedocs and the help docs, the first search result returned will be the frameless html page in the docs for the search term. When searching for the docs for a specific actionscript term, this cuts the search time for a term down to a couple of seconds, which is highly convenient…

To install, uncompress this script and put it in your ~/Library/Application Support/Quicksilver/Actions directory, and restart Quicksilver.

To use, invoke Quicksilver and type “.” to enter text mode. Type all or part of the name of the person you wish to IM. Hit and type “Adium” (or “Ad” or “Adi”) and select “AdiumContactor” with the arrow keys and hit .

The script will search for any instance of the text you enter in your contacts, both in their IM names, as well as their display names. If one match is found, it will open an IM window for that contact. If multiple contacts are found, a window will open allowing you to select the one you want, using whatever account it belongs to. (in other words, if you search “bil”, you will be able to choose from “Bill Todd”, bileInMyStomach@gmail.com, actionscriptAbility@hotmail.com, etc.) Careful using some search terms, such as “com”, as it will return all your MSN messenger accounts (whose screennames are defined by the contact’s email address)

PlasticWare Downloadable ::
AdiumContactor for Quicksilver (Aug. 07, 2008)
Download (~10,000 bytes) :: AdiumContactor.zip

export http_proxy=`proxy-config -h`
export https_proxy=`proxy-config -s`
export ftp_proxy=`proxy-config -f`

This will set your environment proxy variables to whatever they are currently set to in your Network Preferences. I got part of this also from Ryan Tomayko’s blog.This is important if you are inside a firewall at work.

The simplest way to post a tweet to twitter from the command line would be to do so using cURL. If you don’t have cURL installed, you will need to install it. If you aren’t familiar with cURL, it is basically a command-line tool for grabbing html documents (or whatever else). See this post for another use. I got this idea, as well as the applescript for using it with Quicksilver, from Coda Hale’s blog. Read that post for a full explanation of using Quicksilver and an applescript for posting to twitter from Quicksilver — it has a pretty thorough explanation.

If you are inside a firewall, however, this will likely fail because the cURL command requires that the proxy settings be provided. So, I took the script from Coda’s post, combined it with the comment on his post from Daan Kortenbach, and then enabled that for use with the system’s proxy settings. The new script follows:

using terms from application "GrowlHelperApp"
	-- Register Growl
	on growlRegister()
		tell application "GrowlHelperApp"
			register as application "Tweet" all notifications {"Alert"} default notifications {"Alert"} icon of application "Quicksilver.app"
		end tell
	end growlRegister
	
	-- Notify using Growl
	-- Example: growlNotify("This is an Alert","This is a test of the Growl Alert System")
	on growlNotify(grrTitle, grrDescription)
		tell application "GrowlHelperApp"
			notify with name "Alert" title grrTitle description grrDescription application name "Tweet"
		end tell
	end growlNotify
end using terms from

using terms from application "Quicksilver"
	on process text tweet
		tell application "Keychain Scripting"
			set twitter_key to first Internet key of current keychain whose server is "twitter.com"
			set twitter_login to quoted form of (account of twitter_key & ":" & password of twitter_key)
		end tell
		set twitter_status to quoted form of ("status=" & tweet)
		
                -- I have proxy-config in a directory "~/bin"
		set the_proxy to do shell script "~/bin/proxy-config -h"
		
		try
			if (the_proxy = "") then
				set results to do shell script "curl --user " & twitter_login & " --data-binary " & twitter_status & " http://twitter.com/statuses/update.json"
			else
				set results to do shell script "curl --proxy " & the_proxy & " --user " & twitter_login & " --data-binary " & twitter_status & " http://twitter.com/statuses/update.json"
			end if
			growlRegister()
			growlNotify("Tweet Sent", tweet)
		on error
			(* In case curl fails for some reason,  alert us *)
			growlRegister()
			growlNotify("Error", "There was an error sending your tweet.")
		end try

	end process text
end using terms from

Today I deafened myself, but upon searching, discovered Alloc Init, which features a nice little app called Breakaway. The main feature of this app is to pause iTunes or launch the screensaver when the headphone jack status is changed (plugged in or out). However, the nicer thing about the app is that it also allows the user to trigger an applescript on the same events. I created the following script called setVolumeTo20of100:

tell application "Finder"
set volume output volume 20
end tell

After creating a custom trigger in Breakaway, my system volume will always be reset to 20 when I plug in something to the headphone jack. Since I don’t care about having to increase the volume at home automatically, this is fine for now, since I will most importantly not deafen myself in the morning at work. I will perhaps post an update later that checks the the network preferences for the current location for setting the volume automatically based on location, which will automate things a little more. Meanwhile, I highly recommend this nice little app. (Note: the interface for creating custom triggers is a little clunky, so you may have to play with it a little first, but it does work — just be patient.)

The solution: I decided it was finally time to resurface the site, but do so quickly so as to actually get things working again. So, the current state you see here is the result. Not finished, but at least not entirely broken. I did a little research, and decided that I would try out the Sandbox theme. I appreciated what they are trying to do, and I also decided that I should go ahead and start basically from scratch with a foundation that has some nice semantic markup to build on.

The project: What you see here in progress is actually a new theme that I am building on top of Sandbox, tentatively called Plastic Laminate, utilizing pretty much just new CSS on top of the existing Sandbox for now, and then I may actually do some reskinning or plugin building as well, to cover any areas missing content I want. That being said, if things look a bit wonky or like a blog with little design effort applied at the moment, that’s because its still in transition…

I found this nice MacWorld article that discusses some of the newer (or at least new to me) functionality in Preview for OSX, which details some really nice features, including document merging and annotation, as well as some nice formatting features. Looking forward to using this for making designeriffic podcast/mix PDF booklets, multipage Illustrator-formatted resumes, and whatever else.