Demonastery Blog

LogPixels DPI hack

Wed, 04 Jan 12 23:32:06 +1300

Here's a handy tip for those netbook users out there in dire need of more screen estate. You can force a DPI value of lower than 96 by using the Windows registry. To do so open Regedit, navigate to HKEY_CURRENT_CONFIG/Software/Fonts/LogPixels and change the decimal value from 96 to something lower such as 80. Then log out and back in and you will see the changes. I'm using a value of 80 on my netbook and it is about the most that I will drop it while still keeping things (half) readable. You will notice that it really hinders the readability of fonts as well as having some strange bitmap scaling artifacts, but if you're like me and can adjust to it then the extra screen space gained is well worth it :)

You can view a side by side comparison of the my desktop with LogPixels at 80 and at 96 by viewing this imgur album.

Docstrings in my Chicken?

Sun, 13 Nov 11 17:39:39 +1300

Here's a little bit of amateur code to enable the use of docstrings in Chicken Scheme. I haven't written any Scheme in a few months and don't have any formal training in the ninja art of explicit renaming macros so I'd appreciate any feedback from Scheme veterans:

;;; Docstrings for Chicken!

;; The hash-table that will contain the procedures and their associated
;; documentation strings as well as their code for later use.
(define *documentation-hash-table* (make-hash-table))

;; Documented define er-macro
(define-syntax (define* form r c)
(let* ((args-form (second form)) ; (proc args)
(proc-name (first args-form)) ; proc
(doc (third form)) ; "The docstring"
(body (drop form 3))) ; (everything else)
(hash-table-set! *documentation-hash-table* proc-name (list doc body)) ; insert the doc and code body
`(,(r 'define) ,args-form ,@body))) ; Define the procedure as normal

;; Example of a documented procedure, will print a nice-ish list of documented procedures
(define* (print-docs)
"Print a list of documented procedures"
(hash-table-walk *documentation-hash-table*
(lambda (key val)
(printf "~a => ~a~n ~a~n~n" key (first val) (second val)))))

Another example of why Scheme is such a fun language to work with :)

Twitter's Bootstrap

Fri, 04 Nov 11 15:19:57 +1300

To me, one of the most annoying parts of prototyping a new web application is getting a presentable look and feel up quickly. When I'm prototyping stuff I love to have a good looking interface from the start, even if that interface will be changed before going live.

Recently, Twitter released a wonderful CSS/JS framework named Bootstrap for this exact purpose. As stated it is a toolkit "[...] designed to kickstart development of webapps and sites.". It combines an aesthetically pleasing base styling (based somewhat off of Twitter itself) of HTML elements with an easy to use CSS grid, great browser compatibility, and various optional Javascript modules to extend functionality of things such as Drop-down menus and modal dialogs.

As for the elements it offers, some of my favourites are:

* All typical HTML elements are styled, including decent typography
* A top bar to be used for menus and such, with drop-down menus to be activated easily with JS
* Tabs/Pills
* Ability to pretty-print code when used in conjunction with google-code-prettify
* Labels and buttons, with styles for success, warning, notice, etc
* Alert boxes, with corresponding styles, great for showing form submission status etc

Bootstrap is built on top of the LESS CSS preprocessor for ease of extending and integrating into your apps. Personally I found that the precompiled stylesheet was more than enough to begin with however, and I'm more of a fan of the SASS preprocessor anyway. The JS modules are also very easy to integrate with very little code needed to hook them up to their appropriate classes.

I jumped into Bootstrap shortly after its release, and have been using it ever since for my internal prototypes and eventual applications, including an application in the process of being deployed. Bootstrap played an integral part in getting that project complete under it's tight deadline.

Highly recommended to all!

Das Keyboard Ultimate

Wed, 12 Oct 11 19:31:11 +1300

I took the plunge recently and bought my first mechanical keyboard, the Das Keyboard Ultimate. It was very hard to find someone that would ship one to NZ, but eventually I found AusPCMarket that ships the Das as well as several other "clicky keyboards". The Das is known for being a bit pricey.. the Ultimate set me back $230NZD (incl shipping and GST) at the current exchange rate and was delivered in just over a week. If you need to justify the price by thinking of it as an investment, then do :)

With it being my first mechanical keyboard I'm unable to give a fair review in comparison to others of its kind. My previous keyboard was a Microsoft Comfort Curve 2000 keyboard (a much cheaper $40NZD), a brilliant keyboard but of course based around rubber dome technology.

Anyway, it took me a while to adjust to the non-curved layout of the Das, but now that I have I feel that I am touch-typing much MUCH more efficiently than before. It feels great to type on, plus it sounds amazing! Personally I revel in the sound of the Das, and while I wouldn't want to use one around sleeping people, it certainly won't break through any music playing on your headphones and so far doesn't seem to penetrate walls ;)

Overall a definite thumbs-up from me. If you're in NZ and looking to get a Das, I'd highly recommend also going through AusPCMarket as their service was quick and no-bullshit.

Tiny Memcached Wrapper

Fri, 12 Aug 11 15:48:43 +1200

No posts in a while huh! Been pretty busy and haven't thought of much to blog about lately. But I've been playing with Memcache and wanted to share a tiny class I made to add easy caching to my PHP projects. This PHP class just provides a nice simple interface to use by extending the Memcached class:

// Call the class whatever you want
class MyCache extends \Memcached {
function cache($key, $time, $func) {
if (($val = $this->get($key)) === false) {
$val = $func();
$this->set($key, $val, strtotime($time) - time());
}
return $val;
}
}

And now to use it, first you summon it in the same way as the regular class:

$c = new MyCache;
$c->addServer('127.0.0.1', 11211);

Then where you would like to begin caching (I'm using this very blog as an example, where GeSHi for syntax highlighting is the main bottle-neck for page generation), you call the class like so:

// Example using my BLACK blog engine (http://github.com/ZaneA/BLACK)

// Here is the original line
$row['body'] = render($row['body']);

// And here is a cached version
// As you can see we have a KEY, a TIMEOUT, and a FUNCTION to call for a cache miss
$row['body'] = $c->cache("blog_post_{$row['id']}", '30 minutes', function () use ($row) {
return render($row['body']); // Renders all the post filters, including syntax highlighting
});

Awesome, for this small tweak on my local test blog (with 4 posts), this takes the page response time down from 14ms to 2ms. Quite a win I'd say :)

Of course this code requires the memcached PHP extension and a running Memcache server ;)

Emacs Tip: Vimpulse

Thu, 07 Jul 11 23:05:46 +1200

One thing I love about Emacs is that it is so extensible. I was an avid Vim user for a long time and it took me several tries to switch to Emacs, but I will never look back. With the Vimpulse addon to the built-in viper-mode, Emacs becomes a powerful Vim impersonator, capable of being extended with Emacs-Lisp.

A lot of my time is spent doing web development, and so strong HTML editing ability is essential in any editor I use. Vim has this amazing concept of text objects which allows you to be very efficient when transforming text; one of the most useful when doing web development is therefore the XML/HTML tag text object. I would use this all the time by invoking "cit" to change text between a pair of tags. To demonstrate, here's a piece of text you might have sitting in a file:

Hello |World

Now with the cursor somewhere in between the tags (visualized above by the pipe, '|') we can go into command mode and type "cit" and the above will be replaced with:

Ready to be edited!

Well sadly, Vimpulse doesn't have this feature by default, probably one of the very few parts of Vim that it doesn't emulate in fact! (NB. Evil contains emulation for this already) But not to worry, we can just add it in! This is Emacs after all.

So how do we instruct Vimpulse to recognise another text object? Turns out it's REALLY easy:

(vimpulse-define-text-object vimpulse-tag (arg)
"Select a tag"
:keys '("at" "it") ; The keys that will trigger this text object
(vimpulse-inner-object-range ; We're basically defining a range on which to act upon
arg
(lambda (arg) (search-backward ">" nil nil arg) (forward-char)) ; Look to the left for a ">" character
(lambda (arg) (search-forward "<" nil nil arg) (backward-char)) ; Look to the right for a "<" character
)) ; and return the distance between them!

Note that this isn't a perfect implementation, but for the purposes of this demonstration it will suffice! We can now "cit" and "dit" to our hearts content! Hail Emacs!

For a more robust implementation it may be worth looking at using sgml-skip-tag-backward and sgml-skip-tag-forward for movement instead.

Happy Hacking!

Org-mode Conky Colorizer

Sun, 05 Jun 11 21:37:57 +1200

Just whipped up a little script to colorize my org-mode todo lists for display via Conky. It's bound to be of use to someone so I thought I'd better share :)

Here's a screenshot of it in action, sitting in the corner of my desktop.

Source is below, to use, place ${execp /path/to/org-conky-parser.scm 30} in to your conkyrc. Requires Chicken Scheme, and remember to chmod +x the script first.

#!/usr/bin/csi -script
;; org-conky-parser.scm
;; Run an org-mode file through some regexes and output colors
;; Suitable for Conky.

; File to read, could be easily grabbed from argv
(define *file* "~/org/day.org")
(define *font* "Liberation Sans")

;; Code below

(use regex-literals)
(set-read-syntax! #\/ read-regex-literal)

(define ++ string-append)

(define (color c)
(++ "${color " c "}\\1${color}"))

(define (font f)
(++ "${font " f "}\\1${font}"))

(define *replace-list*
(list
(list /^(\*+)/ (color "#555555"))
(list /(TODO)/ (color "#ffaa88"))
(list /(DONE)/ (color "#aaff88"))
(list /(TODO|DONE)/ (font (++ *font* ":style=bold:pixelsize=12")))
(list /(<.*>)/ (color "#aaaaff"))
(list /(<.*>)/ (font (++ *font* ":style=bold:pixelsize=14")))
(list /(.*list.*)/ (font (++ *font* ":style=bold:pixelsize=16")))))

; Grab file contents into a list
(define *contents*
(with-input-from-file *file* read-lines))

; Colorize a line using above regexes
(define (colorize-line line)
(for-each ; Foreach regex/replacement
(lambda (pair)
(set! line (string-substitute (car pair) (cadr pair) line)))
*replace-list*)
line)

(define print-colorized-line (compose print colorize-line))

; Print colorized lines
(for-each print-colorized-line *contents*)

Adding FreeType to our Demo

Sun, 05 Jun 11 19:09:57 +1200

Continuing on from my Chicken Scheme, and OpenGL tutorial, I'm going to show you how to extend it to render pretty FreeType text using the FTGL library. Follow the code below for details as always; it's really easy! :)

Users of ArchLinux can get FTGL with a simple sudo pacman -S ftgl. Debian should be something like sudo apt-get install libftgl-dev.

Alright lets start by loading up the code from last time ...

... and scrolling down to the "(inline .." call:

(inline #< #ifndef CHICKEN
...
#endif

// Here we're going to add the new stuff for FTGL!

// Define a constant we're going to use later
const int FTGL_RENDER_ALL = 0xffff;

// And typedef FTGLfont as void so we can use it and pass it around
typedef void FTGLfont;

// Notice however that I didn't include the ftgl header, because I
// want to define just the functions we're going to use to make
// things even easier

FTGLfont* ftglCreatePixmapFont(const char*);

void ftglSetFontFaceSize(FTGLfont*, int, int);
void ftglRenderFont(FTGLfont*, const char*, int);
void ftglDestroyFont(FTGLfont*);

// The above are the only ones we will be using for now, but these
// ones below may also be useful, along with the SimpleLayout class

// Also possible to use ftglCreateTextureFont and
// render as a plain texture too! Using the same render call
//FTGLfont* ftglCreatePixmapFont(const char*);

//float ftglGetFontLineHeight(FTGLfont*);
//void ftglGetFontBBox(FTGLfont*, const char*, int, float*);

// Done!

... Now skip down to the EOF part:

EOF
"-lSOIL -lftgl" ; Notice here we have added -lftgl to be linked
)

... Now skip down to our old draw-text function, where we're going to replace the GLUT code with our new FTGL render code:

(define (draw-text text x y #!key (color '(1 1 1 1)))
(apply gl:Color4f color)
(gl:PushAttrib gl:ENABLE_BIT)
(gl:Disable gl:TEXTURE_2D)
(gl:RasterPos2f x y)
; This line has been replaced with a new one for FTGL
; FTGL even takes care of rendering for us!
(ftglRenderFont font text FTGL_RENDER_ALL)
(gl:PopAttrib))

... and down a bit further to where we loaded the texture last time:

(define texture (LoadGLTexture "circle_gradient.tga"))

; And add a new line for loading the font up
(define font (ftglCreatePixmapFont "pathtoyourfont.ttf"))
; with minimal error checking
(unless font
(error "Couldn't load font!")
(exit 1))

; now set the font size
(ftglSetFontFaceSize font 36 36)

... Nearly done! down to the last line now:

(glut:MainLoop)

; Add a call to destroy the font after we're done
(ftglDestroyFont font)

And that's it! Ah the joys of libraries and high level languages!
If all went well you should have sweet anti-aliased variable-pitch text in place of the standard GLUT stuff before :D

More Practical Chicken

Thu, 12 May 11 22:24:33 +1200

As I love sharing code on my blog, and I love Chicken Scheme, I'm going to share a couple of handy and practical features that I've made use of recently.

Anyone that has used C++ for longer than a few minutes has probably noticed that literal constants (numbers and such) often have a suffix attached to them. The most common place that you'll see this is when writing floating-point decimals, ie. 1.0f.

They might seem a little pointless at first, but they have their uses; I swear that I once read of a way to add your own types into the language too.

But anyway, I searched for a way to do this in Chicken too, and it turns out it's really easy (of course!). Chicken provides a function called set-parameterized-read-syntax! that can emulate this functionality quite nicely.

Here's a real world case that I used recently, I wanted to be able to convert from inches into pixels, based on a known DPI (in this case 180). The code to set this up looks like this:

; This lets you type #12i anywhere in your code and have it replaced with 2160
(set-parameterized-read-syntax #\i (lambda (port n) (* n 180)))

Yeah that's really it, isn't Scheme wonderful :P

The other really useful feature is the regex-literals egg (download it with sudo chicken-install regex-literals), which gives Chicken Scheme the ability to use Ruby/Perl/Javascript style literal regexes; well almost, it allows you to type #/myregexhere/i (notice the leading #) and it will be converted into a regexp object. Luckily we can even take this a step further and remove the hash at the front. Code time!

; Import the egg first of all
(use regex-literals)

; Lucky for us, regex-literals provides us the function we need to read
; a full regex literal from a Scheme port, so all we have to do is just
; hook it up to the "/" character and it will work as expected!
(set-read-syntax! #\/ read-regex-literal)

; Now we can write inline regex with a familiar syntax :D
(pp (string-match /.*match[A-Za-z]+me.*/i "hello match world me :D"))

I know this a measly amount of code to be posting an entry for, but I hope that both of these features (among others) demonstrate just how practical Chicken Scheme can be in many situations, and shows that you don't always have to write a large amount of code to get cool things done! Mint!

Org-agenda-sms.el

Thu, 12 May 11 11:07:22 +1200

So my warmup for today was to rewrite my old org-mode agenda notification code to use Emacs lisp instead of Python.
The aim of this code is to check your org-mode agenda for any headings with DEADLINEs and create a vcalendar for each, and then send them to your phone via Clickatell.

To use it, save the code into your Emacs lib path, and then in your .emacs you'll want something like:

(require 'org-agenda-sms)

(setq org-agenda-sms-username "")
(setq org-agenda-sms-password "hunter2")
(setq org-agenda-sms-api-key "")
(setq org-agenda-sms-phone "")

(run-at-time "7am" nil 'org-agenda-sms)

The contents of org-agenda-sms.el is below:

;;
;; Org-agenda-sms.el
;; Allows Emacs to SMS you a vcalendar of appointments each day
;; Written by Zane Ashby (http://www.demonastery.org)
;;
;; Usage: (run-at-time "07am" nil 'org-agenda-sms)
;;

(defvar org-agenda-sms-username nil "Clickatell username for SMS")
(defvar org-agenda-sms-password nil "Clickatell password for SMS")
(defvar org-agenda-sms-api-key nil "Clickatell API key for SMS")
(defvar org-agenda-sms-phone nil "Phone number for SMS")

;;;###autoload
(defun org-agenda-sms-build-vcal (header timestamp)
"Builds a vcalendar from a header and timestamp"
(let ((vcal-template "BEGIN:VCALENDAR
VERSION:1.0
BEGIN:VEVENT
CATEGORIES:APPOINTMENT
DTSTART:%s
DTEND:%s
SUMMARY:%s
DESCRIPTION:%s
END:VEVENT
END:VCALENDAR")
(time (format-time-string "%Y-%m-%d %H%M"
(apply 'encode-time (org-parse-time-string timestamp)))))
(format vcal-template time time header header)))

;;;###autoload
(defun org-agenda-sms-send (text &optional type)
"Send an SMS vcalendar provided by \"text\""
(let* ((text (url-hexify-string text))
(url-format "https://api.clickatell.com/http/sendmsg?user=%s&password=%s&api_id=%s&to=%s&msg_type=%s&text=%s")
(url (format url-format org-agenda-sms-username org-agenda-sms-password org-agenda-sms-api-key org-agenda-sms-phone (if type type "SMS_NOKIA_VCAL") text)))
(message "Retrieving api.clickatell.com/http/sendmsg..")
(url-retrieve-synchronously url)))

;;;###autoload
(defun org-agenda-sms ()
"Check for appointments in org-agenda and SMS as vcalendar to phone"
(org-map-entries
(lambda ()
(let ((heading (clean-org-heading (nth 4 (org-heading-components))))
(props (org-entry-properties)))
(cond
((assoc "DEADLINE" props)
(org-agenda-sms-send (org-agenda-sms-build-vcal heading (cdr (assoc "DEADLINE" props)))))
((assoc "SCHEDULED" props)
(org-agenda-sms-send (org-agenda-sms-build-vcal heading (cdr (assoc "SCHEDULED" props)))))
((assoc "TIMESTAMP" props)
(org-agenda-sms-send (org-agenda-sms-build-vcal heading (cdr (assoc "TIMESTAMP" props))))))))
"TIMESTAMP<=\"<+1d>\"|DEADLINE<=\"<+1d>\"|SCHEDULED<=\"<+1d>\""
'agenda))

(provide 'org-agenda-sms)

Seems to work for me, but as always your mileage may vary ;)

FileTools C++ Class

Sun, 08 May 11 11:55:43 +1200

Here is the source for the FileTools C++ Class promised a few posts back, which uses inotify to monitor files for changes.

Again we start off with the class header:

// FileTools.cpp

#include
#include
#include

typedef class FileTools {
public:
static int addWatch(char *, ...);
static void removeWatch(int);
static bool hasChanged(int);

private:
static int fd;
} *pFileTools;

// Parse variable arguments into 'buffer' character array
// This is just a macro I use often in my functions
#define parsevargs(buff, buffer) \
char buffer[128]; \
memset(buffer, 0, sizeof(buffer)); \
va_list ap; \
va_start(ap, buff); \
vsnprintf(buffer, sizeof(buffer), buff, ap); \
va_end(ap);

And on to the implementation:

int FileTools::fd = 0;

int FileTools::addWatch(char *path, ...)
{
// Parse variable arguments into "buffer"
parsevargs(path, buffer);

// Initialize inotify if need be
if (!FileTools::fd) FileTools::fd = inotify_init();

printf("Adding Watch for %s..\n", buffer);

// Return a new watch handle
return inotify_add_watch(FileTools::fd, buffer, IN_CLOSE_WRITE);
}

void FileTools::removeWatch(int wd)
{
printf("Removing Watch id = %i..\n", wd);
inotify_rm_watch(FileTools::fd, wd);
}

#define EVENT_SIZE (sizeof(struct inotify_event))
#define BUF_LEN (1024 * (EVENT_SIZE + 16))
bool FileTools::hasChanged(int wd)
{
bool ret = false;

// Return from select immediately if none available
struct timeval time;
time.tv_sec = 0;
time.tv_usec = 0;
fd_set rfds;

FD_ZERO(&rfds);

// Set up our fd_set with our inotify fd
FD_SET(FileTools::fd, &rfds);

// Do the select
select(FileTools::fd + 1, &rfds, NULL, NULL, &time);

if (FD_ISSET(FileTools::fd, &rfds)) {
int length = 0;
int i = 0;
char buffer[BUF_LEN];

length = read(FileTools::fd, buffer, BUF_LEN);

while (i < length) {
// Got a match
struct inotify_event *event = (struct inotify_event*)&buffer[i];

if (event->wd == wd &&
event->mask & IN_CLOSE_WRITE) {
// It was a file we were monitoring!
printf("Watched file %i has changed\n", wd);
ret = true;
}

i += EVENT_SIZE + event->len;
}
}

return ret;
}

And that's it! Use to your hearts content, this code and the CodeTools code before it are free to use for whatever purpose you want.

Sorry for the short post, but I want to post more Scheme (and maybe PHP) instead of cluttering up my blog with C++ ;)

CodeTools C++ Class

Sat, 07 May 11 22:13:11 +1200

As promised a couple of posts back, I will present a C++ class to compile some arbitrary code using GCC and load it into memory.

The code is pretty simple, we start off with the class header:

// CodeTools.hpp

#include
#include
#include

typedef class CodeTools {
public:
static bool compileString(char*, bool (*callback)(void*));
static bool compileFile(char*, bool (*callback)(void*));

private:
} *pCodeTools;

And then on to the compileString method. This method actually just wraps compileFile to avoid code duplication, so it's really just taking in a string and writing it to a temporary file before calling compileFile.

Here we go:

// CodeTools.cpp

bool CodeTools::compileString(char* code, bool (*callback)(void*))
{
// Generate a temporary file name
// (There are better ways to do this!)
char temp[256];
sprintf(temp, "codetools_XXXXXX");
char* tmppath = mktemp(temp);

// Open temporary file
FILE* fp = fopen(tmppath, "wb");

if (!fp) {
fprintf(stderr, "Could not open temporary path %s\n", tmppath);
return false;
}

// Write out string
fwrite(code, strlen(code), sizeof(char), fp);
fclose(fp);

// Call out to compileFile method
bool ret = compileFile(tmppath, callback);

// Remove temporary file
unlink(tmppath);

return ret;
}

So again, just a small wrapper, which can be reimplemented to your liking.

Now for the part that does the actual work, this can be cleaned up plenty but seems pretty stable for me:

bool CodeTools::compileFile(char* path, bool (*callback)(void*))
{
// Increments each time this function is called.
// This is used for the .so path. If the .so path
// doesn't change then our new functions won't
// override the old ones.
static int count = 0;

// A buffer to hold our command line
char buffer[256];
memset(buffer, 0, sizeof(buffer));

// The last path used
char sopathLast[256];
memset(sopathLast, 0 , sizeof(sopathLast));

// The current path to use
char sopath[256];
memset(sopath, 0 , sizeof(sopath));

sprintf(sopathLast, "./%s.%i.so", path, count - 1);
sprintf(sopath, "./%s.%i.so", path, count++);

// Please change modify these to your liking! These are what I use
// for my livecoding playground
sprintf(buffer, "g++ -shared -o %s -fPIC -fno-use-cxa-atexit -xc++ -include src/Global.hpp %s -Isrc -I/usr/include/freetype2", sopath, path);

// Call it!
int ret = system(buffer);

if (ret != 0) {
fprintf(stderr, "Error in compilation: g++ returned %i\n", ret);
return false;
}

// Cool, compile was successful!

// Now, try to get a handle to the last opened .so so we can close it
void* handle = dlopen(sopathLast, RTLD_LAZY | RTLD_NOLOAD);
if (handle) {
fprintf(stderr, "Found current handle %s, closing first\n", sopathLast);
dlclose(handle);
}

// Open the new .so, LAZY load symbols for speed
handle = dlopen(sopath, RTLD_LAZY);

if (!handle) {
fprintf(stderr, "Could not load compiled file into memory: %s\n", dlerror());
unlink(sopath);
return false;
}

printf("Loaded %s\n", sopath);

// Remove temporary .so
unlink(sopath);

// Call the user supplied callback passing the .so handle to it
// From there it can load individual functions.
return callback(handle);
}

And done. This should be all the code needed to use the CodeTools sample from the C++ Eval? Hell yes. post. Have fun! I will be posting the FileTools class shortly too.

Fun with Renoise and Fluxus

Mon, 02 May 11 21:54:38 +1200

Amidst my experimentations with livecoding I decided to purchase the amazing Renoise Tracker (and overall DAW) while it is on special (30% discount!). My intentions are to play around with Renoise to make music (online and off), and using the built in OSC and JACK support, coordinate the music using Fluxus, and of course be able to respond to it. I am also toying with the idea of using an Arduino or two as input devices. Fun stuff I reckon :P

For anyone wondering how to make Fluxus respond to the Renoise audio, it is simple using JACK:

; If I remember correctly you may need to connect the Renoise
; output to the Fluxus input using something like qjackctl first

(start-audio "renoise:output_01_left" 1024 44100) ; This will tell Fluxus to listen to the left channel..
(gain 1)

; .. and later in your render loop, using the "gh" function you can react to the sound
(every-frame
(begin
(scale (vmul (vector (gh 1) (gh 2) (gh 3)) 0.1))
(draw-torus)))

Pretty neat. Using OSC it is also really simple to control Renoise. First you will want to enable the OSC server in the Renoise preferences, and then you can use the following:

(osc-destination "osc.udp://localhost:8000") ; With the port you specify in the preferences
(osc-send "/renoise/song/bpm" "i" (list 120)) ; Set the BPM to 120
(osc-send "/renoise/transport/start" "" (list)) ; Start playback
(osc-send "/renoise/transport/stop" "" (list)) ; Stop playback

Next up is to get Fluxus working nicely with Emacs.. and I promise some more updates will come shortly (including the code I've promised) :)

C++ Eval? Hell yes.

Sat, 16 Apr 11 12:02:34 +1200

Recently I've been getting back into live coding, and as part of that I have been experimenting with a simple livecoding framework in C++.

One of my experiments involves using C++ as a "scripting language", by compiling code on the fly (using g++, but any compiler should work) into a shared object, and then dlopen-ing the resultant file and hooking up the necessary functions.

By doing this I can have full access to the engine/framework and speed is never a concern. It also means I can modify it later to load any arbitrary shared object (ie. generated via C or any other language, perhaps Chicken?).

The workflow I desired to achieve was to have an OpenGL context open, blank at first. From there I could open the editor of my choice, hack on some high level C++/OpenGL, and when I saved the file, the engine would recompile the file and load it, causing its rendering function to be overridden with the new one.

I'm happy to say I've achieved what I was after!

I will be posting the relevant source to do this in the next post, but for now I will say that it involves a very simple class called FileTools that wraps inotify on the Linux operating system (so it will need to be ported for other OS's, or a generic polling solution could be used very easily, by simply resorting to stat), which allows one to watch a file with some simple code that looks like this:

int fd = FileTools::addWatch("test.cpp");

while (mainloop) {
if (FileTools::hasChanged(fd)) { // Uses select internally
// Cool!
}
}

FileTools::removeWatch(fd);

For my engine to extend this to include recompilation, I have another class called CodeTools, which wraps system and dlopen.
This is also very easy to use, it looks like this:

if (FileTools::hasChanged(fd)) {
CodeTools::compileFile("test.cpp", [](void* handle) {
Renderer::renderp render = (Renderer::renderp)dlsym(handle, "render");
if (render) // Hook 'er up
::engine.renderer->userRender = render;
});
}

Here we are passing a path to a file to compile, and a function (I'm using C++0x lambdas here) that takes a valid handle from dlopen.

Using this class it is also possible to using compileString to compile a string via temp files.

Oh and a screenshot for those wanting to see it in action!

Change GTK display on the fly

Sat, 09 Apr 11 13:54:45 +1200

While working on my netbook away from my desktop machine, I pondered how I could view my email clients display (claws-mail, a GTK app), without having to resort to something such as VNC.

I know this can be done using utilities such as xmove, which essentially act as a proxy X server that can detach a client from one display and move it to another. But this requires you to start xmove before the application, and to tell the application to launch with its display on xmove.

Nah. We need something cooler than this.

After using some Google fu it became apparent that the GTK library has a function named gtk_window_set_screen which is demonstrated in the gtk-demo application that comes with the GTK sources. This function allows the application to switch X11 display on the fly.. provided the application has a way to do so (which none do, because why would they bother).

So I decided to look into ways of doing code injection in Linux, as a way of being able to call that function inside our target application. Turns out this is easy as pie using GDB.

First of all, we need to create a small library that contains our code. This will be loaded into memory and executed by us later. The code I hacked together looks like this (no guarantees whatsoever that this will work on your machine):

// Include the headers we will need
#include
#include

// Now write the function we will be executing.
// This one takes a string containing the display to connect to
void change_display(char *display_str)
{
GdkDisplay *display = gdk_display_get_default();
GtkWidget *toplevel = NULL;

GdkWindow *window = NULL;
GtkWidget *widget = NULL;

// Not 100% necessary but gives you time before the line below this one runs
sleep(5);

// This line gets the GDK window below the cursor
window = gdk_display_get_window_at_pointer(display, NULL, NULL);
if (window) {
gdk_window_get_user_data(window, (gpointer)&widget);

toplevel = gtk_widget_get_toplevel(widget);

GdkDisplay *new_display = gdk_display_open(display_str);
if (new_display)
gtk_window_set_screen(GTK_WINDOW(toplevel), gdk_display_get_screen(new_display, 0));
else
fprintf(stderr, "Could not connect to display \"%s\"\n", display_str);
} else {
fprintf(stderr, "No window found\n");
}

// By this point the window should have moved itself to the display you passed in
}

Cool. So now we just need to compile it and we're a step closer to winning:

gcc -shared -fPIC -o lib lib.c `pkg-config --libs --cflags gtk+-2.0`

Now we should be left with our library sitting in our current directory. Now we can actually inject the code. For this part, we will fire up GDB, attaching to the program we wish to move:

gdb attach `pidof claws-mail`

A bunch of lines will scroll by, which you can largely ignore for this exercise, but you should be left with a nice (gdb) prompt. Now it's time to inject our code!

(gdb) print (void*)dlopen("/path/to/your/current/directory/lib", 2)

Yep, GDB has now loaded our library into the memory space of the application. Now we can run our function :)

(gdb) print change_display("192.168.1.2:0")

If we now quickly move our cursor over to the window of the application. After a few seconds the window should successfully move to the proper display.

Pretty easy huh? :D There are plenty more things you can achieve with simple code injection like this, and for the purpose of this exercise, we could have written a GTK module instead. But this is just cool.