Bugfixes!

2010

I uploaded GlassCalc 1.30 a few days ago, but a combination of strange network problems and lack of time has kept me from writing about until now.  Thanks to the most bizarre network error I have ever seen, I cannot update the changelog page, but I can update everything else.  Until I get some help from the campus network people, I’ll post the changes here.

This version mostly fixes a number of bugs.  The inverse trig functions were all completely wrong.  I promise I will never again blindly copy-paste code without testing it.  There are also a number of fixes for non-default multiplication signs.  I’ve also added a delete function, which is just another alias for unset, and undefine.

I am currently rewriting the parser code to separate it from the UI thread. This means GlassCalc will no longer freeze while performing long calculations like solve, and I can implement things like evaluating as you type.  I have very little knowledge about multi-threaded applications, so the process is long, hard, and completely unlike what those of you with dirty minds are now thinking about.  You can check the roadmap to see what else I am working on.

Aug 29, 2010: v1.30.1

  • Fixed a problem with uppercase E not being recognized in exponential notation.  This also fixed a problem with very large/small scale factors.

Aug 26, 2010: v1.30

  • Fixed inverse trig functions (they were broken thanks to blind copy-paste. I’ve implemented unit tests to help keep this from happening again)
  • Non-default multiplication sign gets proper syntax highlighting
  • Syntax highlighting preview now uses correct multiplication sign
  • Non-default multiplication sign will now trigger “ans” autocompletion.
  • sinh and cosh now work with degree angles.
  • factorial now works on negative numbers
  • Added arccos, arcsin, arctan… aliases for acos, asin, atan…
  • Added atan2(y,x). This is actually an alias for atan(y,x).
  • You can no longer define functions with the same name as aliases.
  • Added delete command as another alias for unset and undefine
  • UI fixes. Clicking to the left of a result now selects it. Input box background color is once-again changeable.

Transcription: The Girl in the Drawing

2010

Here’s a transcription of The Girl in the Drawing from Durarara!! (or Dulalala!!, or Drrr!!, or デュラララ!!, or however else you want to say it) for violin and piano.  This is the first time I’ve transcribed something other than a piano solo, and it was a little difficult to tweak Lilypond into doing what I wanted, but I think it turned out well.

You can listed to the original song on Youtube here.  The link below will take you to my sheet music page, where you can download the combined score and the individual violin and piano parts.  The combined score does not have the dynamics for the violin part, because it broke the formatting and pushed the score onto another page.

The title in its original Japanese is 絵の中の少女 (E no naka no shōjo).

Please tell me what you think! Comments, suggestions on what to transcribe next, etc. are all welcome!

Durarara!!: The Girl in the Drawing

2010

This is The Girl in the Drawing (絵の中の少女 E no naka no shōjo) from Durarara!! (or Dulalala!!, or Drrr!!, or デュラララ!!, or however else you want to say it) for violin and piano. This is the first time I’ve transcribed something other than a piano solo, and it was a little difficult to tweak Lilypond into doing what I wanted, but I think it turned out well.

Full score | Piano part | Violin part | MIDI | Lilypond | Original Song | Tutorial

GlassCalc 1.29 and Widgets!

2010

GlassCalc 1.29 doesn’t add any new functions, but it adds a number of formatting features to make GlassCalc easier to work with or just fit into your theme better.  GlassCalc now has support for thousands separators, and you can choose between commas, spaces of various widths, or enter your own separator.  GlassCalc can also replace asterisks (multiplication operators) with dots or times symbols.

You can now choose between three different formats for exponential form: 1.00e10, 1.00E10, and 1.00×1010.  GlassCalc defaults to a lowercase e to give a clear separation between the number and exponent.  More color settings are available, and the font sizes of the history, input, and other panes are now configurable as well.

Widgets!

I recently created two Opera Widgets, which are essentially desktop applications built with HTML, CSS, and JavaScript.  You need to install Opera before they will work, though Opera does not need to be running to start the applications.

Search Organizer

If you are an Opera user and wished you could reorder your custom search engines, check out my Search Organizer widget.  Feed it your search.ini file and it lets you drag and drop your search engines into a new order.  Save and restart Opera for your changes to apply.

CSS Fix

My second widget isn’t exclusively for Opera users, though it may be more useful to them.  Occasionally, I’ll run into a site that looks blocky and ugly in Opera, but smooth and pretty in Firefox and Chrome, even though Opera supports most or all of the features used *cough* Twitter *cough*.  There’s no reason these sites should look any worse in one browser compared to the others, except that the web developers left out some key CSS properties, like the unprefixed border-radius and box-shadow.

CSS Fix aims to solve this problem by generating CSS patches to fix sites.  It knows most of the equivalent CSS properties used by Opera, Firefox, Chrome/Safari, and Konqueror and can translate between them.   Simply enter the URLs of a offending sites and/or CSS files, choose the browser(s) you want a patch for, and CSS Fix will download the files and generate a new stylesheet with all the missing CSS properties.  You can export the patch as user CSS or user JavaScript, install the patch in your browser, and see sites the way they were meant to be seen.  (You could also ask the site admins to kindly add in the missing properties, but for big sites like Twitter, you’d be lucky to get anywhere)

I’ve created a Twitter patch for Opera using CSS Fix that gives Twitter the rounded corners and most of the other pretty effects it’s supposed to have.

I am also working on a web-based version of CSS Fix that lets you paste in CSS and a user JavaScript version which will fix inline styles on the fly.  I can’t estimate when either of those will be done though.

More Downtime and a New Version

2010

A few months ago, my (free) web host outgrew their servers and moved to bigger and better servers, resulting in a few weeks of downtime.  Everything seemed to be going fine until one of the new servers showed signs of hard-disk failure.  Naturally, my site was on said server, so my site suffered another week of downtime.  A week ago, my host was having trouble with cPanel and discovered an undocumented (and unchangeable) connection limit hidden within it.  The cPanel team said they couldn’t fix it quickly, so my site was down for a few more days while my host reconfigured things to work around the problem.

Everything looks to be stable now, but I predict that in about a week, a series of tornadoes will strike the building housing the servers, and the following week, x10hosting headquarters will be attacked by a giant robotic space eel.

GlassCalc 1.28

On a more serious note, I’ve uploaded version 1.28 of GlassCalc which should fix the bottoms of letters getting cut off in the menu bar.  I’ve also reorganized the settings window and added a couple features to help set up unit conversions.  Last but not least, I’ve added support for something I’m calling “Scale Factors”.  These are suffixes you stick on the end of numbers to multiply them by some number.  If you define a scale factor of K = 1000, you can write 1K for 1000. These have a higher priority than other operators, so 1/1K would be 1/1000, not 1/1*1000.

There are no scale factors defined by default, but you can define your own by editing your extensions.ini file (open More Settings->Extensions).  Add a [ScaleFactors] section and add one suffix per line under it.  The format is Suffix = Scale where Suffix is a string and Scale is a number.  Put a /i at the end of a suffix to make it case-insensitive. You can also use exponential notation when setting the scale. Here is an example ScaleFactors section which defines m (milli), c (centi), K (kilo), and M (mega) suffixes:

[ScaleFactors]
m = 1e-3
c = 1e-2
K/i = 1e3
M = 1e6

Suffixes do not have to be a single character. They can be of any length. You can also use regular expression syntax, but I don’t recommend it. Using square brackets or equals will probably confuse the ini parser, starting with digits (and various other patterns) will confuse the math parser, and everything after the first forward slash is treated as modifier flags. If anyone wants more in-depth support for regular expressions here, ask and I’ll find a way to make it work.

Aero Glass in GlassCalc (part 1)

2010

I got a couple questions about how I made the Aero Glass effects in GlassCalc. When I started making GlassCalc, I had no idea how to manage Aero Glass, but Google came to my rescue. What I eventually came up with is the amalgamation of code snippets and general knowledge from countless separate articles and examples. I’ll link to as many of those pages as I can remember, but I’ll try and bring everything together in one place here.

Note: GlassCalc is written in C# using WPF for its UI. As such, some of the code examples below are C#, .NET, or WPF specific.

Every window in Windows has a client area and a non-client area. The client area is everything you get to handle and draw on. Normally, this is everything inside the window frame. The non-client area is everything Windows handles by itself: the window frame, icon, window title, min/max/close buttons, resize handles, etc…

Using the Windows API, programs can modify the glass frame and the client/non-client areas. Generally, they either extend the glass frame into the client area, or they extend the client area into the glass frame. GlassCalc does both.

With the default interface, GlassCalc extends the top and bottom of the frame. The client area is still the same size, but the glass frame has been extended into the client area, so GlassCalc can draw the menu and the input box over glass.

[singlepic id=6 w=320 h=240 float=center]

With the full glass interface, GlassCalc extends the frame to cover the entire window, so everything is drawn over glass, but it also draws the menu bar inside the title. This is done by extending the client area upwards so GlassCalc can draw there. This effect takes quite a lot more work, because now that GlassCalc has taken over the non-client area, it must handle all the things Windows used to handle in this area.

[singlepic id=13 w=320 h=240 float=center]

Extending the glass frame

All of the code here involves Windows API calls in some way. To organize everything, I’m putting all Windows API functions and structures in a class called Interop. (some examples use the name NativeMethods) I’ll also make a class called GlassHelper which will (quite appropriately) help deal with Aero Glass.

To extend the glass frame, we need to import a function called DwmExtendFrameIntoClientArea from dwmapi.dll. Since Aero can be disabled, we also need to know whether we can extend the frame or not. For this, we import DwmIsCompositionEnabled. DwmExtendFrameIntoClientArea takes a Margins structure as one of its arguments. Since there is no Margins structure in C#, we need to define it ourselves. Much of the following code comes from this informative article.

Note: You can copy the source of these code examples by hovering over the code, then clicking the view source icon in the toolbar that appears in the upper-right corner.

public static class Interop
{
    [StructLayout(LayoutKind.Sequential)]
    public struct Margins
    {
        public int Left;
        public int Right;
        public int Top;
        public int Bottom;
        public Margins(Thickness t)
        {
            Left = (int)t.Left;
            Right = (int)t.Right;
            Top = (int)t.Top;
            Bottom = (int)t.Bottom;
        }
    }
    [DllImport("dwmapi.dll", PreserveSig = false)]
    public static extern void DwmExtendFrameIntoClientArea(IntPtr hwnd, ref Margins margins);
    [DllImport("dwmapi.dll", PreserveSig = false)]
    public static extern bool DwmIsCompositionEnabled();
}

Now, we’ll make a class that can make use of these functions.

public static class GlassHelper
{
    /// <summary>
    /// Gets whether dwmapi.dll is present and DWM functions can be used
    /// </summary>
    public static bool IsDwmCompositionAvailable
    {
        get
        {
            // Vista is version 6.  Don't do aero stuff if not >= Vista because dwmapi.dll won't exist
            return Environment.OSVersion.Version.Major >= 6;
        }
    }
    /// <summary>
    /// Gets whether DWM is enabled
    /// </summary>
    public static bool IsDwmCompositionEnabled
    {
        get
        {
            // Make sure dwmapi.dll is present.  If not, calling DwmIsCompositionEnabled will throw an exception
            if (!IsDwmCompositionAvailable)
                return false;
            return Interop.DwmIsCompositionEnabled();
        }
    }
    /// <summary>
    /// Extends the glass frame of a window
    /// </summary>
    public static bool ExtendGlassFrame(Window window, Thickness margin)
    {
        if (!IsDwmCompositionEnabled)
            return false;
        IntPtr hwnd = new WindowInteropHelper(window).Handle;
        if (hwnd == IntPtr.Zero)
            throw new InvalidOperationException("The Window must be shown before extending glass.");
        HwndSource source = HwndSource.FromHwnd(hwnd);
        // Set the background to transparent from both the WPF and Win32 perspectives
        window.Background = Brushes.Transparent;
        source.CompositionTarget.BackgroundColor = Colors.Transparent;
        Interop.Margins margins = new Interop.Margins(margin);
        Interop.DwmExtendFrameIntoClientArea(hwnd, ref margins);
        return true;
    }
}

Finally, in override your application’s OnSourceInitialized method to call ExtendGlassFrame. The Thickness object you pass in defines how far in the frame should be extended from each of the sides. If you use -1 for each dimension (like in the code below), the glass will cover the entire window.

public sealed partial class YourApp : Window<
{
    . . .
    protected override void OnSourceInitialized(EventArgs e)
    {
        base.OnSourceInitialized(e);
        GlassHelper.ExtendGlassFrame(this, new Thickness(-1));
    }
    . . .
}

Make the glass area act like an extension of the title bar

If you extend the frame from the top such that the title bar appears bigger, (like in the default GlassCalc interface) you probably also want to make it so that when a user clicks in this empty area, they can drag the window. You can do this by detecting a MouseLeftButtonDown event inside the extended title bar area and calling your window’s DragMove function.

What if Aero gets disabled while my program is running?

There is one other thing you should take care of when extending the frame. If a user turns off Aero while your application is running, you’ll get big black areas where there used to be glass because your window background is transparent. Windows sends a WM_DWMCOMPOSITIONCHANGED message to your application when Aero is turned on or off, so you can handle this by setting up a function to listen for this message.

Add this constant to Interop.

public static class Interop
{
    public const int WM_DWMCOMPOSITIONCHANGED = 0x031E;
    . . .
}

Now, set up a function to listen for messages. When it gets a WM_DWMCOMPOSITIONCHANGED message, check to see whether Aero was enabled or disabled. If Aero was enabled, extend the frame again. If it was disabled, set the background color back to its original value. (This example assumes your window background was white. You could improve it by saving the background color before extending the frame, then reverting it when Aero is disabled.)

public sealed partial class YourApp : Window
{
    . . .
    /// <summary>
    /// Processes messages sent to this window
    /// </summary>
    private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
    {
        if (msg == Interop.WM_DWMCOMPOSITIONCHANGED)
        {
            if (GlassHelper.IsDwmCompositionEnabled)
            {
                // Aero was re-enabled.  Extend the glass again.
                GlassHelper.ExtendGlassFrame(this, new Thickness(-1));
            }
            else
            {
                // Aero was disabled.  Reset the window's background color to remove black areas
                HwndSource source = PresentationSource.FromVisual(this) as HwndSource;
                source.CompositionTarget.BackgroundColor = Colors.White;
                this.Background = Brushes.White;
            }
        }
    }
    protected override void OnSourceInitialized(EventArgs e)
    {
        base.OnSourceInitialized(e);
        // Hook up the WndProc function so it receives messages
        HwndSource source = PresentationSource.FromVisual(this) as HwndSource;
        source.AddHook(WndProc);
        GlassHelper.ExtendGlassFrame(this, new Thickness(-1));
    }
    . . .
}

Extending the client area

Since this is already a very long post, and the part on extending the client area will probably be even longer, I’m going to split it up. Extending the client area into the frame will come in part 2… whenever I get around to writing that. For now, here are some of the links I found most useful while figuring this stuff out.

Update 8/19/2010: I know it’s been over a month since I posted part 1, and I still haven’t gotten to part 2.  I’m working on it, but school is start back up, so I can’t say when it’ll be done.

Putting Netbeans AppData in the Right Place

2010

If you use Windows Vista/7 and Netbeans, you’ve likely seen a .netbeans and .netbeans-registration folder appear in your user directory. Netbeans is a very nice piece of software, but like many open-source programs, it goes by the mistaken belief that application data always goes in the home folder. This is perfectly normal for Linux, but Windows is not Linux. Windows application settings go in the AppData folder. It is possible to get Netbeans to store its settings in the right place, and it isn’t too difficult.

This guide will show you how to put Netbeans settings in the right place for Windows Vista/7, but you can also use it to put the settings directories anywhere you want on any system. I’ll assume you are using Netbeans 6.9. If not, change the version number where appropriate.

Find netbeans.conf

Open an explorer window and find the directory where Netbeans is installed. The default location is C:\Program Files\Netbeans 6.9 (C:\Program Files (x86)\Netbeans 6.9 for 64 bit systems). Inside it, there should be a folder called etc and inside that, a file called netbeans.conf. Run an instance of your preferred text editor as administrator (you won’t be able to save the file otherwise) and open netbeans.conf in it.

Change netbeans_default_userdir

The second line of netbeans.conf defines the settings directory. Change it to look like this:

# ${HOME} will be replaced by JVM user.home system property
netbeans_default_userdir="${HOME}/AppData/Roaming/Netbeans"

If you move your .netbeans and .netbeans-registration folders to this new location, Netbeans will pick up your settings, but it will still create the same two directories in your user directory and it will ask you to register again. This is because there are actually two options you need to change. The second one is a little harder to find.

Define -J-Duser.home

Line 6 of netbeans.conf defines a bunch of options, each starting with -J. You need to add another option to this line. Before the quote at the end of the line, add this: (replace USERNAME with your username)
[code lang=”text” light=”true”]-J-Duser.home=C:/Users/USERNAME/AppData/Roaming/Netbeans[/code]

Your netbeans.conf file should look something like this now.

# ${HOME} will be replaced by JVM user.home system property
netbeans_default_userdir="${HOME}/AppData/Roaming/Netbeans"
 
# Options used by NetBeans launcher by default, can be overridden by explicit
# command line switches:
netbeans_default_options="-J-client -J-Xss2m -J-Xms32m -J-XX:PermSize=32m -J-XX:MaxPermSize=200m -J-Dapple.laf.useScreenMenuBar=true -J-Dsun.java2d.noddraw=true -J-Duser.home=C:/Users/USERNAME/AppData/Roaming/Netbeans"
# Note that a default -Xmx is selected for you automatically.
. . .

And now you’re done! Netbeans should no longer clutter your user directory with its settings.

Downtime, Updates, and Glass!

2010

First off, sorry about the recent downtime. My (free) host had a failing hard drive. Naturally, my site was on that drive, and it took a while to move everything to another server and reconfigure it.

I recently finished a Visual Studio 2010 extension that automatically closes braces (because Microsoft still hasn’t implemented it, and there’s no way I’m buying something like ReSharper). Because I am boring and unoriginal, I have named it Brace Completer. You can find it in the software section.

I also updated my Opera/Firefox userscripts with a couple enhancements. The accented character shortcuts script loads a bit sooner on Opera, and the MangaFox script can now use session/localStorage to cache image urls, making things load faster if you return to a previously loaded chapter.

Lastly, I have an update for GlassCalc, which fixes an overflow error with base conversions, a freeze with long input strings of all the same letter, a bug with updates, and a few other things. The full changelog can be found here. Also, I decided that, for a program named GlassCalc, my calculator didn’t have nearly enough glass. I have now remedied this oversight.

[singlepic id=13 w=320 h=240 float=center]

Go to the Options->More Settings page and check Full Glass UI to turn it on. You’ll obviously need Vista or Windows 7 for it to work.

Speaking of things named GlassCalc, as it turns out, the name I chose in an inspired moment of uncreativity has been in use by an English software company for some 25 years. Whoops. They asked if I would link to their site, which I will gladly do here and now (as well as some other places around the site).

Glass Software UK
Glasscalc Ltd are the leading software developers in the specialist field of Pricing / Costing and Invoicing systems for the Glass Industry.

If you happen to be looking for software that deals with actual glass, go check it out!

Adsense, Without Blocking

2010

My web pages pause at ads for a moment. Why?

In some (but not necessarily all) web browsers, if you place a script in the middle of a web page, it has to be executed before the browser can continue rendering the page. The AdSense script is quite slim, but your browser still has to request the JavaScript file from Google, which could take a while depending your Internet speed. This means your pages might load up to the ad, pause a little while, then continue loading. Fortunately, there is a very simple way to keep scripts from blocking your content: put them at the end of the page. This way, all your content is loaded before the scripts are downloaded and executed. Unfortunately, this also puts all your ads at the bottom of the page, but with a little JavaScript, you can put your ads back where they belong.

How to fix it

First, you’ll need some sort of placeholder for where an ad should go. Use a div and set its id so you can easily find it with JavaScript. If you have multiple ads, number the ids so you can replace them all with a loop.

<div id="ad-0"> <!-- the first ad goes here --> </div>
<div id="ad-1"> <!-- a second ad goes here --> </div>

Now, place the AdSense JavaScript at the end of the page. Put each ad inside a div with an id so you can easily find it with JavaScript. Put the everything in a div with display set to none so your ads won’t briefly appear at the bottom of the page.

<div style="display:none">
  <div id="adsource-0">
    <script type="text/javascript"><!--
    google_ad_client = "pub-xxxxxxxxxxxxxxxx";
    /* Ad Name */
    google_ad_slot = "##########";
    google_ad_width = 125;
    google_ad_height = 125;
    //-->
    </script>
    <script type="text/javascript"
    src="http://pagead2.googlesyndication.com/pagead/show_ads.js">
    </script>
  </div>
  <div id="adsource-1">
    ...
  </div>
</div>

Finally, use JavaScript to move each ad to its proper place. This script uses document.getElementById to find the ad and the placeholder, then it uses appendChild to move the ad into the placeholder div.

<script type="text/javascript">
numAds = 1;
for (var i = 0; i < numAds; i++) {
    source = document.getElementById("adsource-" + i);
    placeholder = document.getElementById("ad-" + i);
    placeholder.appendChild(source);
}
</script>

How well does it work?

Consider this entire site a live tech demo. Refresh the page and watch under the “Advertisements” header of the sidebar. After all of the content is loaded, the ads pop into place.

It breaks my layout!

With this setup, the placeholders initially take up no space, so they expand when the ad gets loaded. If this breaks your layout, you can set the height and width of the placeholder to the dimensions of the ad like this:

<div id="ad-0" style="width: 125px; height: 125px"> <!-- this placeholder takes up space! --> </div>

Edit (A bit later, still June 4)

Apparently, this is what I get for writing a post about AdSense. See? This is why we can’t have nice things.

Transcription: Can still see the light

2010

This is a transcription of the piano version of Can still see the light from Phantasy Star Online Songs of RAGOL Odyssey. Soundtrack EP 1 & 2. I’ve always wanted to transcribe this and, well, now I have. You can listen to the original song on YouTube here. The link below will take you to my sheet music page, where you can find the download links.

Please tell me what you think! Comments, suggestions on what to transcribe next, etc. are all welcome!