Hans Van Slooten

Fun with technology

Remapping Caps Lock to Control in Windows

Years ago — before the creation of Sublime Text — I regularly used Emacs for editing (yes, even on Windows). For anyone who has any familiarity with Emacs, they know that you use the Control key like breathing air. Unfortunately, most keyboards were designed like the Control key was meant for the occasional tap, not continuous usage.

"The Control Key is in a bad place"

Because of this, I learned that you could remap the Caps Lock key to Left Control to make it more readily available to my RSI plagued hands. Invariably, though, I would have to search the web for the correct registry incantation to invoke this change. Tiring of this, I’ve decided to simply host the solution on this blog. What follows is the necessary changes, as well as an brief explanation of how this works.

Editing the Registry to Remap Caps Lock to Control

To implement this change, you will need to be an Administrator on your machine (although there may be a solution for non-Administrators).

First, open the following registry key in the Registry Editor (regedit.exe):

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layout

Then create a REG_BINARY value named Scancode Map with the following value:

00000000 00000000 02000000 1D003A00 00000000

What Does it All Mean?

  • All numbers are in little-endian format (as would be expected on a PC).
  • The first two 32-bit (or 4-byte) blocks just need to be set to zero (0).
  • The third 32-bit block is the number of remaining 32-bit blocks in the data.
  • The fourth 32-bit block (in the example above):
    • The first 16-bits, 1D00, is the scancode of the key to map TO. In this case, Left Control.
    • The second 16-bits, 3A00, is the scancode of the key to map FROM. In this case, Caps Lock.
  • The final 32-bit block (in this case, the fifth block, but could be different depending on the number of mappings you create) is simply a null value (i.e. 0).

Other Useful Scancodes

If you are a vim user or just want to map different keys, here are some additional scancodes:

  • 0100 – Escape
  • 2A00 – Left Shift
  • 3600 – Right Shift
  • 1DE0 – Right Control
  • 3800 – Left Alt
  • 38E0 – Right Alt
  • 5BE0 – Left Windows
  • 5CE0 – Right Windows
  • 5DE0 – Windows Menu

Monospaced Developer Fonts

I’ve dabbled in creating monospaced fonts primarily for programming purposes. Here are the results.

VGAToo

VGAToo is a Windows bitmap font that can be used in a console window. It’s based on the standard VGA text font.

Download VGAToo Font

ProFontBold

ProFontBold is simply a modification of the True Type ProFont provided here. It was missing the bold version which tends to be useful, so I added it.

Download the ProFontBold Font

Building an ASP.NET MVC Site in F#

With the introduction of Microsoft Visual Studio 2010, F# has become a first-class citizen of the .NET world. Well, that’s the theory anyway. While I appreciate the work that Microsoft has done to make functional programming more accessible to the wider development community, F# is still not quite on equal footing with languages like C# and VB.NET. This is to be expected, as it is still a very new language, and I have no doubt that Microsoft will continue to improve support for F# in the .NET ecosystem.

That said, one of the most exciting areas in the .NET world these days is the introduction of ASP.NET MVC over the past year or so. While the open source world has had many options for the MVC development pattern in web applications (Ruby on Rails, Django, etc.), the .NET world has not had as many options. ASP.NET MVC has changed that and allows developers in the .NET world to develop web applications in a much more natural and testable way than the traditional WebForm model.

Which brings us to the issue at hand. While Visual Studio 2010 provides templates for building ASP.NET MVC applications in C#/VB.NET, it doesn’t provide them for F#. There are a few tutorials available on the web for this (see here, here, and here), but none of them were quite what I was looking for: a simple structure for building ASP.NET MVC applications completely in F# with as little overhead as possible. After a little experimentation (and the help of the aforementioned tutorials), I was able to achieve my goal.

Setup

Before getting into the code, you should first setup a directory structure that makes sense. Here is the structure that I used along with the initial files that you’ll need. Just leave the files empty for now.

.
├─ Global.asax
├─ Global.asax.fs
├─ web.config
├─ App_Code
|  └─ HelloWorldController.fs
├─ Views
|  └─ HelloWorld
|     └─ Example.spark
├─ bin
|  ├─ Spark.dll
|  └─ Spark.Web.Mvc.dll
├─ scripts
└─ css

You probably noticed the Example.spark as well as the Spark.dll and Spark.Web.Mvc.dll. This is because I chose to use the Spark View Engine after discovering that the built-in ASPX View Engine (besides using the horrible ASPX formatting) also doesn’t play well with F# (or possibly the other way around). If you attempt to use it, you will probably see an error like this:

That FS0442: Duplicate method. The abstract method 'ProcessRequest' has the same name and signature as an abstract method in an inherited type. is due to the way that the F# code generator works with the MVC ViewPage object. I’m not sure if there is any way around it because I just switched to the Spark View Engine.

So, rather than stretch this out any further, below is all of the source code necessary to get this working. Once this is setup, you can point IIS at the folder and then access the MVC URLs like:

http://localhost/mvcfs/HelloWorld/Index
http://localhost/mvcfs/HelloWorld/Foo
http://localhost/mvcfs/HelloWorld/Bar 
http://localhost/mvcfs/HelloWorld/Example

Ultimately, I think this is a clean, efficient implementation that shows the elegance of the F# language (inspired by OCaml) as well as the ability to use it to leverage the .NET Framework.

Source Code

Global.asax 
1

<%@ Application CodeFile="Global.asax.fs" Inherits="MyMvcNamespace.MyMvcApplication" Language="F#" %>
Global.asax.fs 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

namespace MyMvcNamespace

open System.Web.Mvc
open System.Web.Routing
open Spark.Web.Mvc

type MvcConstraint = { controller:string; action:string; id:string }

type MyMvcApplication() =
    inherit System.Web.HttpApplication()

    static member RegisterRoutes(routes: RouteCollection) =
        routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
        routes.MapRoute(
            "Default",
            "{controller}/{action}/{id}",
            { controller = "HelloWorld"; action = "index"; id = "" })

    member x.Application_Start() =
        MyMvcApplication.RegisterRoutes RouteTable.Routes
        ViewEngines.Engines.Add(new SparkViewFactory())
HelloWorldController.fs 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

namespace MyMvcNamespace.Controllers

open System.Web.Mvc

type HelloWorldController() =
    inherit Controller()

    member x.Index() =
        "Default Index View.."

    member x.Foo() =
        x.Content "<h2>Foo</h2>"

    member x.Bar() =
        x.Content "<h2>Bar</h2>"

    member x.Example() =
        x.ViewData.["Hans"] <- "This is a test"
        x.View()
Example.spark 
1
2
3
4
5
6
7
8
9
10

<var names="new [] {'alpha', 'beta', 'gamma'}"/>
<for each="var name in names">
  <test if="name == 'beta'">
    <p>beta is my favorite.</p>
    <else/>
    <p>${name} is okay too I suppose.</p>
  </test>
</for>
<p>
<b>${ViewData["Hans"]}</b>
web.config 
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

<?xml version="1.0"?>
<configuration>
  <system.codedom>
    <compilers>
      <compiler language="F#;f#;fs;fsharp"
                extension=".fs"
                type="Microsoft.FSharp.Compiler.CodeDom.FSharpAspNetCodeProvider,
                      FSharp.Compiler.CodeDom,
                      Version=2.0.0.0,
                      Culture=neutral,
                      PublicKeyToken=a19089b1c74d0809"/>
    </compilers>
  </system.codedom>

  <system.web>
    <compilation debug="true" targetFramework="4.0">
      <assemblies>
        <add assembly="System.Web.Abstractions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" />
        <add assembly="System.Web.Routing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" />
        <add assembly="System.Web.Mvc, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" />
      </assemblies>
    </compilation>

        <pages>
      <namespaces>
        <add namespace="System.Web.Mvc" />
        <add namespace="System.Web.Mvc.Ajax" />
        <add namespace="System.Web.Mvc.Html" />
        <add namespace="System.Web.Routing" />
      </namespaces>
    </pages>
  </system.web>

  <system.webServer>
    <validation validateIntegratedModeConfiguration="false"/>
    <modules runAllManagedModulesForAllRequests="true"/>
  </system.webServer>

  <runtime>
    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
      <dependentAssembly>
        <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35" />
        <bindingRedirect oldVersion="1.0.0.0" newVersion="2.0.0.0" />
      </dependentAssembly>
    </assemblyBinding>
  </runtime>
</configuration>