Code Formatting in Blogger

I've several hours of research, trial, and error, I've finally come across a workable solution for formatting code snippets in Blogger. Here are the basic steps:
  1. From your dashboard view, click "Template" and then "Edit HTML".  A modal confirmation dialog will appear.  Click "Proceed".
  2. Find the <head> tag and insert the following on the next line: 
    <link href='https://sites.google.com/site/itswadesh/codehighlighter/shCore.css' rel='stylesheet' type='text/css' />
    <link href='http://sites.google.com/site/itswadesh/codehighlighter/shThemeDefault.css' rel='stylesheet' type='text/css' />
    <script src='http://sites.google.com/site/itswadesh/codehighlighter/shCore.js' type='text/javascript' />
    <script src='http://sites.google.com/site/itswadesh/codehighlighter/shBrushCSharp.js' type='text/javascript' />
    <script src='http://sites.google.com/site/itswadesh/codehighlighter/shBrushJava.js' type='text/javascript' />
    <script src='http://sites.google.com/site/itswadesh/codehighlighter/shBrushCss.js' type='text/javascript' />
    <script src='http://sites.google.com/site/itswadesh/codehighlighter/shBrushXml.js' type='text/javascript' />
    <script type='text/javascript'>
        // Required for Blogger:
        SyntaxHighlighter.config.bloggerMode = true;
        // Set to true to enable line numbers:
        SyntaxHighlighter.defaults['gutter'] = false;
        // Apply formatting:
        SyntaxHighlighter.all();
    </script>

  3. Save the template

Once your template is updated, simply wrap your code snippets in a <pre> tag with a special class: 

<pre class="brush: csharp">
public class Test
{
    public string Property { get; set; }

    public void Method()
    {
    }
}
</pre>

The result should look something like this: 
public class Test
{
    public string Property { get; set; }

    public void Method()
    {
    }
}

The full list of brushes can be found here. Note that the HTML snippet in step 2 above only imports the C#, Java, XML, and CSS brushes. If, for example, you wanted to use Erlang, you would also have to include the following <script> tag: 

    <script src='http://sites.google.com/site/itswadesh/codehighlighter/shBrushErlang.js' type='text/javascript' />

Comments

Post a Comment

Popular posts from this blog

Non-nullable Reference Types

A few days ago on InfoQ I saw a link to this blog post offering a solution to "The Billion Dollar Mistake" : allowing null references. The proposal, non-nullable reference types, is designed to replace this: /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="argument"/> is null. /// </exception> public void Method(SomeType argument) { if (argument == null) { throw ArgumentNullException("argument"); } // Do stuff... } With something like this: public void Method(SomeType! argument) { // Do stuff... } Of course complications arise with arrays of non-nullable reference types and with the methods that feature non-nullable output parameters. There are workarounds for those issues, but the result is a convoluted syntax and unnecessary overhead. But I think the main problem is that we're looking at the problem from the wrong direction. I think we have to accept
Read more

Objects Are People, Too

Determining what state or behaviors to expose on an object can be difficult.  We all know the basic rules—encapsulate logic, only expose immutable value objects, and so on—but putting those rules into practice does not come naturally.  In fact, given our heritage of anemic, relational models, it’s almost unnatural .  Several years ago I remember reading about SOLID and other OOP principles and thinking to myself, how on earth would you persist that? Of course not all objects are persistent, and having the benefit of experience I now know that the view, domain, and persistence models need not be one and the same.  That being the case, there are incredible benefits to encapsulation, if done properly.  But how exactly does one put aside relational habits? One trick I have is to imagine objects have personalities and imagine how they would react if I asked certain questions or requested certain behaviors.  For example, suppose I had a Person object and I wanted to know where they were
Read more

Named Locks and Lock Striping

Suppose there is a function to which a reference to some arbitrary resource is passed (a file name, for example). The function needs exclusive access to that referenced resource, but should allow concurrent access to other resources. On the one hand, a single lock object would synchronize all calls to the function, which would ruin concurrency. On the other hand, the references are arbitrary, so the number of lock objects required is non-deterministic. Framework support for named locks is kind of thin. The .NET framework offers named mutexes . For .NET developers this seems like an obvious choice, but since they are system-level they are very tricky to implement properly and can get out of sync very easily. One more broadly applicable approach I've seen involves locking on the interned string representation of the resource reference. Any two references that are the same will convert to the same interned string instance, so the lock will prevent concurrent access. Meanwhile
Read more