Index: uspace/app/vcalc/Makefile
===================================================================
--- uspace/app/vcalc/Makefile	(revision 4bf0926eafdfba5eb055645d92feb2f44e40542f)
+++ uspace/app/vcalc/Makefile	(revision 4bf0926eafdfba5eb055645d92feb2f44e40542f)
@@ -0,0 +1,48 @@
+#
+# Copyright (c) 2012 Petr Koupy
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+USPACE_PREFIX = ../..
+
+LIBS = \
+	$(LIBGUI_PREFIX)/libgui.a \
+	$(LIBDRAW_PREFIX)/libdraw.a \
+	$(LIBSOFTREND_PREFIX)/libsoftrend.a \
+	$(LIBSOFTFLOAT_PREFIX)/libsoftfloat.a
+
+EXTRA_CFLAGS += \
+	-I$(LIBGUI_PREFIX) \
+	-I$(LIBDRAW_PREFIX) \
+	-I$(LIBSOFTREND_PREFIX)
+
+BINARY = vcalc
+MATH = y
+
+SOURCES = \
+	vcalc.c
+
+include $(USPACE_PREFIX)/Makefile.common
Index: uspace/app/vcalc/vcalc.c
===================================================================
--- uspace/app/vcalc/vcalc.c	(revision 4bf0926eafdfba5eb055645d92feb2f44e40542f)
+++ uspace/app/vcalc/vcalc.c	(revision 4bf0926eafdfba5eb055645d92feb2f44e40542f)
@@ -0,0 +1,588 @@
+/*
+ * Copyright (c) 2016 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup vcalc
+ * @{
+ */
+/** @file
+ *
+ * Inspired by the code released at https://github.com/osgroup/HelenOSProject
+ *
+ */
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <malloc.h>
+#include <io/pixel.h>
+#include <task.h>
+#include <window.h>
+#include <grid.h>
+#include <button.h>
+#include <label.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <str.h>
+
+#define NAME  "vcalc"
+
+#define NULL_DISPLAY  "."
+
+#define SYNTAX_ERROR_DISPLAY   "syntax error"
+#define NUMERIC_ERROR_DISPLAY  "numerical error"
+#define UNKNOWN_ERROR_DISPLAY  "unknown error"
+
+typedef enum {
+	STATE_INITIAL = 0,
+	STATE_FINISH,
+	STATE_ERROR,
+	STATE_DIGIT,
+	STATE_VALUE
+} parser_state_t;
+
+typedef enum {
+	ERROR_SYNTAX = 0,
+	ERROR_NUMERIC
+} error_type_t;
+
+typedef enum {
+	OPERATOR_NONE = 0,
+	OPERATOR_ADD,
+	OPERATOR_SUB,
+	OPERATOR_MUL,
+	OPERATOR_DIV
+} operator_t;
+
+typedef enum {
+	ITEM_VALUE = 0,
+	ITEM_OPERATOR
+} stack_item_type_t;
+
+typedef struct {
+	link_t link;
+	
+	stack_item_type_t type;
+	union {
+		int64_t value;
+		operator_t operator;
+	} data;
+} stack_item_t;
+
+static char *expr = NULL;
+static label_t *display;
+
+static bool is_digit(char c)
+{
+	return ((c >= '0') && (c <= '9'));
+}
+
+static int get_digit(char c)
+{
+	assert(is_digit(c));
+	
+	return (c - '0');
+}
+
+static bool is_plus(char c)
+{
+	return (c == '+');
+}
+
+static bool is_minus(char c)
+{
+	return (c == '-');
+}
+
+static bool is_finish(char c)
+{
+	return (c == 0);
+}
+
+static operator_t get_operator(char c)
+{
+	switch (c) {
+	case '+':
+		return OPERATOR_ADD;
+	case '-':
+		return OPERATOR_SUB;
+	case '*':
+		return OPERATOR_MUL;
+	case '/':
+		return OPERATOR_DIV;
+	default:
+		return OPERATOR_NONE;
+	}
+}
+
+static bool is_operator(char c)
+{
+	return (get_operator(c) != OPERATOR_NONE);
+}
+
+static bool stack_push_value(list_t *stack, int64_t value, bool value_neg)
+{
+	stack_item_t *item = malloc(sizeof(stack_item_t));
+	if (!item)
+		return false;
+	
+	link_initialize(&item->link);
+	item->type = ITEM_VALUE;
+	
+	if (value_neg)
+		item->data.value = -value;
+	else
+		item->data.value = value;
+	
+	list_prepend(&item->link, stack);
+	
+	return true;
+}
+
+static bool stack_push_operator(list_t *stack, operator_t operator)
+{
+	stack_item_t *item = malloc(sizeof(stack_item_t));
+	if (!item)
+		return false;
+	
+	link_initialize(&item->link);
+	item->type = ITEM_OPERATOR;
+	item->data.operator = operator;
+	list_prepend(&item->link, stack);
+	
+	return true;
+}
+
+static bool stack_pop_value(list_t *stack, int64_t *value)
+{
+	link_t *link = list_first(stack);
+	if (!link)
+		return false;
+	
+	stack_item_t *item = list_get_instance(link, stack_item_t, link);
+	if (item->type != ITEM_VALUE)
+		return false;
+	
+	*value = item->data.value;
+	
+	list_remove(link);
+	free(item);
+	
+	return true;
+}
+
+static bool stack_pop_operator(list_t *stack, operator_t *operator)
+{
+	link_t *link = list_first(stack);
+	if (!link)
+		return false;
+	
+	stack_item_t *item = list_get_instance(link, stack_item_t, link);
+	if (item->type != ITEM_OPERATOR)
+		return false;
+	
+	*operator = item->data.operator;
+	
+	list_remove(link);
+	free(item);
+	
+	return true;
+}
+
+static void stack_cleanup(list_t *stack)
+{
+	while (!list_empty(stack)) {
+		link_t *link = list_first(stack);
+		if (link) {
+			stack_item_t *item = list_get_instance(link, stack_item_t,
+			    link);
+			
+			list_remove(link);
+			free(item);
+		}
+	}
+}
+
+static bool compute(int64_t a, operator_t operator, int64_t b, int64_t *value)
+{
+	switch (operator) {
+	case OPERATOR_ADD:
+		*value = a + b;
+		break;
+	case OPERATOR_SUB:
+		*value = a - b;
+		break;
+	case OPERATOR_MUL:
+		*value = a * b;
+		break;
+	case OPERATOR_DIV:
+		if (b == 0)
+			return false;
+		
+		*value = a / b;
+		break;
+	default:
+		return false;
+	}
+	
+	return true;
+}
+
+static unsigned int get_priority(operator_t operator)
+{
+	switch (operator) {
+	case OPERATOR_ADD:
+		return 0;
+	case OPERATOR_SUB:
+		return 0;
+	case OPERATOR_MUL:
+		return 1;
+	case OPERATOR_DIV:
+		return 1;
+	default:
+		return 0;
+	}
+}
+
+static void evaluate(list_t *stack, int64_t *value, parser_state_t *state,
+    error_type_t *error_type)
+{
+	while (!list_empty(stack)) {
+		if (!stack_pop_value(stack, value)) {
+			*state = STATE_ERROR;
+			*error_type = ERROR_SYNTAX;
+			break;
+		}
+		
+		if (!list_empty(stack)) {
+			operator_t operator;
+			if (!stack_pop_operator(stack, &operator)) {
+				*state = STATE_ERROR;
+				*error_type = ERROR_SYNTAX;
+				break;
+			}
+			
+			int64_t value_a;
+			if (!stack_pop_value(stack, &value_a)) {
+				*state = STATE_ERROR;
+				*error_type = ERROR_SYNTAX;
+				break;
+			}
+			
+			if (!compute(value_a, operator, *value, value)) {
+				*state = STATE_ERROR;
+				*error_type = ERROR_NUMERIC;
+				break;
+			}
+			
+			if (!stack_push_value(stack, *value, false)) {
+				*state = STATE_ERROR;
+				*error_type = ERROR_SYNTAX;
+				break;
+			}
+		}
+	}
+}
+
+static void display_update(void)
+{
+	if (expr != NULL)
+		display->rewrite(&display->widget, (void *) expr);
+	else
+		display->rewrite(&display->widget, (void *) NULL_DISPLAY);
+}
+
+static void display_error(error_type_t error_type)
+{
+	if (expr != NULL) {
+		free(expr);
+		expr = NULL;
+	}
+	
+	switch (error_type) {
+	case ERROR_SYNTAX:
+		display->rewrite(&display->widget, (void *) SYNTAX_ERROR_DISPLAY);
+		break;
+	case ERROR_NUMERIC:
+		display->rewrite(&display->widget, (void *) NUMERIC_ERROR_DISPLAY);
+		break;
+	default:
+		display->rewrite(&display->widget, (void *) UNKNOWN_ERROR_DISPLAY);
+	}
+}
+
+static void on_btn_click(widget_t *widget, void *data)
+{
+	const char *subexpr = (const char *) widget_get_data(widget);
+	
+	if (expr != NULL) {
+		char *new_expr;
+		
+		asprintf(&new_expr, "%s%s", expr, subexpr);
+		free(expr);
+		expr = new_expr;
+	} else
+		expr = str_dup(subexpr);
+	
+	display_update();
+}
+
+static void on_c_click(widget_t *widget, void *data)
+{
+	if (expr != NULL) {
+		free(expr);
+		expr = NULL;
+	}
+	
+	display_update();
+}
+
+static void on_eval_click(widget_t *widget, void *data)
+{
+	if (expr == NULL)
+		return;
+	
+	list_t stack;
+	list_initialize(&stack);
+	
+	error_type_t error_type = ERROR_SYNTAX;
+	size_t i = 0;
+	parser_state_t state = STATE_INITIAL;
+	int64_t value = 0;
+	bool value_neg = false;
+	operator_t last_operator = OPERATOR_NONE;
+	
+	while ((state != STATE_FINISH) && (state != STATE_ERROR)) {
+		switch (state) {
+		case STATE_INITIAL:
+			if (is_digit(expr[i])) {
+				value = get_digit(expr[i]);
+				i++;
+				state = STATE_VALUE;
+			} else if (is_plus(expr[i])) {
+				i++;
+				value_neg = false;
+				state = STATE_DIGIT;
+			} else if (is_minus(expr[i])) {
+				i++;
+				value_neg = true;
+				state = STATE_DIGIT;
+			} else
+				state = STATE_ERROR;
+			break;
+		
+		case STATE_DIGIT:
+			if (is_digit(expr[i])) {
+				value = get_digit(expr[i]);
+				i++;
+				state = STATE_VALUE;
+			} else
+				state = STATE_ERROR;
+			break;
+		
+		case STATE_VALUE:
+			if (is_digit(expr[i])) {
+				value *= 10;
+				value += get_digit(expr[i]);
+				i++;
+			} else if (is_operator(expr[i])) {
+				if (!stack_push_value(&stack, value, value_neg)) {
+					state = STATE_ERROR;
+					break;
+				}
+				
+				value = 0;
+				value_neg = false;
+				
+				operator_t operator = get_operator(expr[i]);
+				
+				if (get_priority(operator) <= get_priority(last_operator)) {
+					evaluate(&stack, &value, &state, &error_type);
+					if (state == STATE_ERROR)
+						break;
+					
+					if (!stack_push_value(&stack, value, value_neg)) {
+						state = STATE_ERROR;
+						break;
+					}
+				}
+				
+				if (!stack_push_operator(&stack, operator)) {
+					state = STATE_ERROR;
+					break;
+				}
+				
+				last_operator = operator;
+				i++;
+				state = STATE_DIGIT;
+			} else if (is_finish(expr[i])) {
+				if (!stack_push_value(&stack, value, value_neg)) {
+					state = STATE_ERROR;
+					break;
+				}
+				
+				state = STATE_FINISH;
+			} else
+				state = STATE_ERROR;
+			break;
+		
+		default:
+			state = STATE_ERROR;
+		}
+	}
+	
+	evaluate(&stack, &value, &state, &error_type);
+	stack_cleanup(&stack);
+	
+	if (state == STATE_ERROR) {
+		display_error(error_type);
+		return;
+	}
+	
+	free(expr);
+	asprintf(&expr, "%" PRId64, value);
+	display_update();
+}
+
+int main(int argc, char *argv[])
+{
+	if (argc < 2) {
+		printf("%s: Compositor server not specified.\n", NAME);
+		return 1;
+	}
+	
+	window_t *main_window = window_open(argv[1], NULL,
+	    WINDOW_MAIN | WINDOW_DECORATED | WINDOW_RESIZEABLE, NAME);
+	if (!main_window) {
+		printf("%s: Cannot open main window.\n", NAME);
+		return 2;
+	}
+	
+	pixel_t grd_bg = PIXEL(255, 240, 240, 240);
+	
+	pixel_t btn_bg = PIXEL(255, 0, 0, 0);
+	pixel_t btn_fg = PIXEL(200, 200, 200, 200);
+	
+	pixel_t lbl_bg = PIXEL(255, 240, 240, 240);
+	pixel_t lbl_fg = PIXEL(255, 0, 0, 0);
+	
+	grid_t *grid = create_grid(window_root(main_window), NULL, 4, 5, grd_bg);
+	
+	display = create_label(NULL, NULL, NULL_DISPLAY, 16, lbl_bg, lbl_fg);
+	
+	button_t *btn_1 = create_button(NULL, "1", "1", 16, btn_bg, btn_fg,
+	    lbl_fg);
+	button_t *btn_2 = create_button(NULL, "2", "2", 16, btn_bg, btn_fg,
+	    lbl_fg);
+	button_t *btn_3 = create_button(NULL, "3", "3", 16, btn_bg, btn_fg,
+	    lbl_fg);
+	button_t *btn_4 = create_button(NULL, "4", "4", 16, btn_bg, btn_fg,
+	    lbl_fg);
+	button_t *btn_5 = create_button(NULL, "5", "5", 16, btn_bg, btn_fg,
+	    lbl_fg);
+	button_t *btn_6 = create_button(NULL, "6", "6", 16, btn_bg, btn_fg,
+	    lbl_fg);
+	button_t *btn_7 = create_button(NULL, "7", "7", 16, btn_bg, btn_fg,
+	    lbl_fg);
+	button_t *btn_8 = create_button(NULL, "8", "8", 16, btn_bg, btn_fg,
+	    lbl_fg);
+	button_t *btn_9 = create_button(NULL, "9", "9", 16, btn_bg, btn_fg,
+	    lbl_fg);
+	button_t *btn_0 = create_button(NULL, "0", "0", 16, btn_bg, btn_fg,
+	    lbl_fg);
+	
+	button_t *btn_add = create_button(NULL, "+", "+", 16, btn_bg, btn_fg,
+	    lbl_fg);
+	button_t *btn_sub = create_button(NULL, "-", "-", 16, btn_bg, btn_fg,
+	    lbl_fg);
+	button_t *btn_mul = create_button(NULL, "*", "*", 16, btn_bg, btn_fg,
+	    lbl_fg);
+	button_t *btn_div = create_button(NULL, "/", "/", 16, btn_bg, btn_fg,
+	    lbl_fg);
+	
+	button_t *btn_eval = create_button(NULL, NULL, "=", 16, btn_bg, btn_fg,
+	    lbl_fg);
+	button_t *btn_c = create_button(NULL, NULL, "C", 16, btn_bg, btn_fg,
+	    lbl_fg);
+	
+	if ((!grid) || (!display) || (!btn_1) || (!btn_2) || (!btn_3) ||
+	    (!btn_4) || (!btn_5) || (!btn_6) || (!btn_7) || (!btn_8) ||
+	    (!btn_9) || (!btn_0) || (!btn_add) || (!btn_sub) || (!btn_mul) ||
+	    (!btn_div) || (!btn_eval) || (!btn_c)) {
+		window_close(main_window);
+		printf("%s: Cannot create widgets.\n", NAME);
+		return 3;
+	}
+	
+	sig_connect(&btn_1->clicked, &btn_1->widget, on_btn_click);
+	sig_connect(&btn_2->clicked, &btn_2->widget, on_btn_click);
+	sig_connect(&btn_3->clicked, &btn_3->widget, on_btn_click);
+	sig_connect(&btn_4->clicked, &btn_4->widget, on_btn_click);
+	sig_connect(&btn_5->clicked, &btn_5->widget, on_btn_click);
+	sig_connect(&btn_6->clicked, &btn_6->widget, on_btn_click);
+	sig_connect(&btn_7->clicked, &btn_7->widget, on_btn_click);
+	sig_connect(&btn_8->clicked, &btn_8->widget, on_btn_click);
+	sig_connect(&btn_9->clicked, &btn_9->widget, on_btn_click);
+	sig_connect(&btn_0->clicked, &btn_0->widget, on_btn_click);
+	
+	sig_connect(&btn_add->clicked, &btn_add->widget, on_btn_click);
+	sig_connect(&btn_sub->clicked, &btn_sub->widget, on_btn_click);
+	sig_connect(&btn_div->clicked, &btn_div->widget, on_btn_click);
+	sig_connect(&btn_mul->clicked, &btn_mul->widget, on_btn_click);
+	
+	sig_connect(&btn_eval->clicked, &btn_eval->widget, on_eval_click);
+	sig_connect(&btn_c->clicked, &btn_c->widget, on_c_click);
+	
+	grid->add(grid, &display->widget, 0, 0, 4, 1);
+	
+	grid->add(grid, &btn_1->widget, 0, 1, 1, 1);
+	grid->add(grid, &btn_2->widget, 1, 1, 1, 1);
+	grid->add(grid, &btn_3->widget, 2, 1, 1, 1);
+	grid->add(grid, &btn_add->widget, 3, 1, 1, 1);
+	
+	grid->add(grid, &btn_4->widget, 0, 2, 1, 1);
+	grid->add(grid, &btn_5->widget, 1, 2, 1, 1);
+	grid->add(grid, &btn_6->widget, 2, 2, 1, 1);
+	grid->add(grid, &btn_sub->widget, 3, 2, 1, 1);
+	
+	grid->add(grid, &btn_7->widget, 0, 3, 1, 1);
+	grid->add(grid, &btn_8->widget, 1, 3, 1, 1);
+	grid->add(grid, &btn_9->widget, 2, 3, 1, 1);
+	grid->add(grid, &btn_mul->widget, 3, 3, 1, 1);
+	
+	grid->add(grid, &btn_c->widget, 0, 4, 1, 1);
+	grid->add(grid, &btn_0->widget, 1, 4, 1, 1);
+	grid->add(grid, &btn_eval->widget, 2, 4, 1, 1); 
+	grid->add(grid, &btn_div->widget, 3, 4, 1, 1);
+	
+	window_resize(main_window, 0, 0, 400, 400, WINDOW_PLACEMENT_ANY);
+	window_exec(main_window);
+	
+	task_retval(0);
+	async_manager();
+	
+	return 0;
+}
Index: uspace/app/vlaunch/vlaunch.c
===================================================================
--- uspace/app/vlaunch/vlaunch.c	(revision 10cb47eaa0c19e8c686b3c5e3d3e6084e07b901c)
+++ uspace/app/vlaunch/vlaunch.c	(revision 4bf0926eafdfba5eb055645d92feb2f44e40542f)
@@ -127,12 +127,14 @@
 	button_t *btn_vterm = create_button(NULL, "/app/vterm", "vterm",
 	    16, btn_bg, btn_fg, btn_text);
+	button_t *btn_vcalc = create_button(NULL, "/app/vcalc", "vcalc",
+	    16, btn_bg, btn_fg, btn_text);
 	button_t *btn_vdemo = create_button(NULL, "/app/vdemo", "vdemo",
 	    16, btn_bg, btn_fg, btn_text);
 	button_t *btn_vlaunch = create_button(NULL, "/app/vlaunch", "vlaunch",
 	    16, btn_bg, btn_fg, btn_text);
-	grid_t *grid = create_grid(window_root(main_window), NULL, 1, 5, grd_bg);
+	grid_t *grid = create_grid(window_root(main_window), NULL, 1, 6, grd_bg);
 	
 	if ((!logo_canvas) || (!lbl_caption) || (!btn_vterm) ||
-	    (!btn_vdemo) || (!btn_vlaunch) || (!grid)) {
+	    (!btn_vcalc) || (!btn_vdemo) || (!btn_vlaunch) || (!grid)) {
 		window_close(main_window);
 		printf("Cannot create widgets.\n");
@@ -141,4 +143,5 @@
 	
 	sig_connect(&btn_vterm->clicked, &btn_vterm->widget, on_btn_click);
+	sig_connect(&btn_vcalc->clicked, &btn_vcalc->widget, on_btn_click);
 	sig_connect(&btn_vdemo->clicked, &btn_vdemo->widget, on_btn_click);
 	sig_connect(&btn_vlaunch->clicked, &btn_vlaunch->widget, on_btn_click);
@@ -147,8 +150,9 @@
 	grid->add(grid, &lbl_caption->widget, 0, 1, 1, 1);
 	grid->add(grid, &btn_vterm->widget, 0, 2, 1, 1);
-	grid->add(grid, &btn_vdemo->widget, 0, 3, 1, 1);
-	grid->add(grid, &btn_vlaunch->widget, 0, 4, 1, 1);
+	grid->add(grid, &btn_vcalc->widget, 0, 3, 1, 1);
+	grid->add(grid, &btn_vdemo->widget, 0, 4, 1, 1);
+	grid->add(grid, &btn_vlaunch->widget, 0, 5, 1, 1);
 	
-	window_resize(main_window, 0, 0, 210, 130 + LOGO_HEIGHT,
+	window_resize(main_window, 0, 0, 210, 164 + LOGO_HEIGHT,
 	    WINDOW_PLACEMENT_RIGHT | WINDOW_PLACEMENT_TOP);
 	window_exec(main_window);