Recently I released a part of my AutoHotKey script to the Internets and called it Kommand. Kommand remaps your keyboard and enables VIM-like key bindings that are useful for scooting around a document and making changes. I’ve found it very useful for coding. The nice thing is that since it is an AutoHotKey script, it is application independent and works wherever text input is needed. In addition to text editing, Kommand provides many keyboard shortcuts that help in window management. You can close, restore, maximize, minimize, and move windows around the screen really easily and quickly.

Kommand is very early software and I am only putting it out there to see if anyone is interested. More information about it can be found in the AutoHotKey forums here:

http://www.autohotkey.com/forum/viewtopic.php?p=281279

Kommand can be downloaded from the following link. The source AutoHotKey script is included along with a few files and executables that are useful for integrating it with Windows. If you use it, please let me know what you think!

http://www.kylirhorton.com/kommand.zip

cPickle.PicklingError: Can't pickle <type 'method-wrapper'>: attribute lookup __builtin__.method-wrapper failed

None of my Gentoo geek buddies knew what was up. After trying a few things, I came up with a good solution: manually reinstall emerge/portage. I found an excellent tutorial on how to do this at gentoo.org:

http://www.gentoo.org/proj/en/portage/doc/manually-fixing-portage.xml

I began having problems with the Axialis icon editing toolbar in Visual Studio a few weeks ago. It would appear as a short, empty, ugly little toolbar within Visual Studio. I would remove it, even delete it out of Visual Studio, and it still hung around and appeared there every time I started up. Fortunately for me, this problem has a simple fix.

If you’re using a x86 machine, edit the following within the registry:
Key: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\9.0\AddIns\IconWorkshopAddin.Connect
Set value CommandPreload to 0×00000000 (0).

If you’re using a x64 machine, edit the following within the registry:
Key: HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\9.0\AddIns\IconWorkshopAddin.Connect
Set value CommandPreload to 0×00000000 (0).

References:

http://www.axialis.com/forum/viewtopic.php?f=4&t=2179

First, make sure your application has an App.config file. If it is missing, add it by going to Project > Add New Item… and then selecting “Application Configuration File” from the pop up. Visual Studio will then add a blank App.config file to your application. Open it and make it look something like this:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<appSettings>
<add key="PreferenceToRemember" value="DefaultValue" />
</appSettings>
</configuration>

In order to write to this App.config file, you will need to add System.Configuration as a project reference. And of course you’ll need to have the appropriate usings statements on the right forms. Once all that is done, you can write to the App.config file with the following:

Configuration oConfig = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
oConfig.AppSettings.Settings["PreferenceToRemember"].Value = "NewValue";
oConfig.Save(ConfigurationSaveMode.Modified);
ConfigurationManager.RefreshSection("appSettings");

The last line in the code above refreshes the current in-memory configuration with what is saved inside the App.config file. To read from the App.config file, just use this:

string strPreferenceToRemember = ConfigurationManager.AppSettings["LastProject"];

As a final note, I noticed that nothing seemed to be written to the configuration file while debugging within Visual Studio, but once I published the application it worked as expected. I don’t know why this happens, but I’ll modify this post if I find out.

(#([0-9A-Fa-f]{3,6})\b)|

(aqua)|(black)|(blue)|(fuchsia)|

(gray)|(green)|(lime)|(maroon)|

(navy)|(olive)|(orange)|(purple)|

(red)|(silver)|(teal)|(white)|(yellow)|

(rgb\(\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*,

\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*,

\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*\))|

(rgb\(\s*(\d?\d%|100%)+\s*,\s*(\d?\d%|100%)+\s*,\s*(\d?\d%|100%)+\s*\))

Just as a recap, a valid CSS color can be represented as a…

1. named color, such as “red”, “green”, “blue”, “black”, etc.
2. hexadecimal value, such as #ff0000 (red), #00ff00 (green), #0000ff (blue), #000000 (black), etc. Some hexadecimal values can be reduced to just three characters. For example, red is #f00 and green is #0f0.
3. triplet consisting of the color’s RGB values, such as rgb(255,0,0) for red and rgb(0,255,0) for green.

The Regular Expression listed above should be able to handle any of the variants that a CSS color can throw at it.

Application, Page, and Control Life Cycles
Application: BeginRequest
Application: PreAuthenticateRequest
Application: AuthenticateRequest
Application: PostAuthenticateRequest
Application: PreAuthorizeRequest
Application: AuthorizeRequest
Application: PostAuthorizeRequest
Application: PreResolveRequestCache
Application: ResolveRequestCache
Application: PostResolveRequestCache
Application: PreMapRequestHandler
Page: Construct
Application: PostMapRequestHandler
Application: PreAcquireRequestState
Application: AcquireRequestState
Application: PostAcquireRequestState
Application: PreRequestHandlerExecute
Page: AddParsedSubObject
Page: CreateControlCollection
Page: AddedControl
Page: AddParsedSubObject
Page: AddedControl
Page: ResolveAdapter
Page: DeterminePostBackMode
Page: PreInit
Control: ResolveAdapter
Control: Init
Control: TrackViewState
Page: Init
Page: TrackViewState
Page: InitComplete
Page: LoadPageStateFromPersistenceMedium
Control: LoadViewState
Page: EnsureChildControls
Page: CreateChildControls
Page: PreLoad
Page: Load
Control: DataBind
Control: Load
Page: EnsureChildControls
Page: LoadComplete
Page: EnsureChildControls
Page: PreRender
Control: EnsureChildControls
Control: PreRender
Page: PreRenderComplete
Page: SaveViewState
Control: SaveViewState
Page: SaveViewState
Control: SaveViewState
Page: SavePageStateToPersistenceMedium
Page: SaveStateComplete
Page: CreateHtmlTextWriter
Page: RenderControl
Page: Render
Page: RenderChildren
Control: RenderControl
Page: VerifyRenderingInServerForm
Page: CreateHtmlTextWriter
Control: Unload
Control: Dispose
Page: Unload
Page: Dispose
Application: PostRequestHandlerExecute
Application: PreReleaseRequestState
Application: ReleaseRequestState
Application: PostReleaseRequestState
Application: PreUpdateRequestCache
Application: UpdateRequestCache
Application: PostUpdateRequestCache
Application: EndRequest
Application: PreSendRequestHeaders
Application: PreSendRequestContent

Page and Control Life Cycles with Pretty Pictures!

References:
http://weblogs.asp.net/Jeff/archive/2004/07/04/172683.aspx
http://www.eggheadcafe.com/articles/20051227.asp

The Problem
Lately I’ve been experiencing some frustrating problems with references to DLL files in a Visual Studio solution. Since I’m working with a team of other programmers, we are obviously using a code versioning system—in this case SourceSafe. It seems that nearly every time I “get the latest version” of the solution from SourceSafe and then try to build it, I will get errors with references to missing DLLs. However, the “missing DLLs” actually exist. The problem is that the references to these DLLs within the solution are wrong.

Because each of the other programmers have a different path to their own copies of the same solution, they also have different paths to the DLLs that are included in that solution. One programmer will notice that his stuff isn’t compiling, he’ll fix the reference error, check it in, and then simultaneously break it on all the other programmers’ machines (Or at least all those will a different file structure).

The Fix
To fix it, you’ll want to use “Reference Paths” within Visual Studio:

1. In Solution Explorer, right-click your project node and click Properties. The Project Designer should appear.
2. If you are using Visual Basic, select the References page and click the Reference Paths button. In the Reference Paths dialog box, type the path of the folder that contains the DLL that you want to reference in the Folder field, then click the Add Folder button. If you are using C#, select the Reference Paths page. In the Folder field, type the path of the folder that contains the item you want to reference, and then click the Add Folder button.

That’s it! Reference Paths are saved within each user’s own profile, so they will not be propagated to the other SourceSafe users when you check in your files. When you build a solution, Visual Studio will first try to find the DLL with the hardcoded path that is provided within the solution. If it can’t find it, then it will look within the Reference Paths for the file, where you should now have the correct reference to the DLLs.

References:

http://msdn2.microsoft.com/en-us/library/ayds71se(VS.80).aspx