add example

git-svn-id: svn://kolibrios.org@6455 a494cfbc-eb01-0410-851d-a64ba20cac60

contrib/C_Layer/Example/Example_C/example_c.c

@@ -0,0 +1,105 @@
+#include "kolibri_gui.h"
+#include "kolibri_kmenu.h"
+#include "kolibri_libimg.h"
+
+int main()
+{
+  /* Load all libraries, initialize global tables like system color table and
+     operations table. kolibri_gui_init() will EXIT with mcall -1 if it fails
+     to do it's job. This is all you need to call and all libraries and GUI
+     elements can be used after a successful call to this function
+  */
+  kolibri_gui_init();
+  kolibri_kmenu_init();
+  kolibri_libimg_init();
+  /* Set gui_event to REDRAW so that window is drawn in first iteration  */
+  unsigned int gui_event = KOLIBRI_EVENT_REDRAW;
+  oskey_t key;
+
+  struct kolibri_window *main_window = kolibri_new_window(50, 50, 420, 350, "Example 2");
+  struct check_box *checkbox = kolibri_new_check_box(20, 30, 12, 12, "Print to BOARD selected menu item.");
+  
+  kolibri_window_add_element(main_window, KOLIBRI_CHECK_BOX, checkbox);
+    
+  extern volatile unsigned press_key;
+  
+  ufile_t load_f;
+  load_f = load_file("/kolibrios/111.png");
+  void* image_data_rgb = (void*)malloc(load_f.size);
+  void* image_data = img_decode(load_f.data, load_f.size, 0);
+  img_to_rgb2(image_data, image_data_rgb);
+  //img_destroy(image_data);	
+  
+  void* main_menu;
+  void* main_menu_file;
+  void* main_menu_edit;
+  kmenu_init(NULL);
+  main_menu = ksubmenu_new();
+  main_menu_file = ksubmenu_new();
+  main_menu_edit = ksubmenu_new();
+  ksubmenu_add(main_menu_file, kmenuitem_new(0, "Open", 110));
+  ksubmenu_add(main_menu_file, kmenuitem_new(0, "Save", 111));
+  ksubmenu_add(main_menu_file, kmenuitem_new(2, NULL, 112));
+  ksubmenu_add(main_menu_file, kmenuitem_new(0, "Exit", 113));
+  ksubmenu_add(main_menu, kmenuitem__submenu_new(1, "File", main_menu_file));
+  ksubmenu_add(main_menu_edit, kmenuitem_new(0, "Vertical flip", 120));
+  ksubmenu_add(main_menu_edit, kmenuitem_new(0, "Horizontal flip", 121));
+  ksubmenu_add(main_menu, kmenuitem__submenu_new(1, "Edit", main_menu_edit));
+  
+  do  /* Start of main activity loop */
+    {
+      if(gui_event == KOLIBRI_EVENT_REDRAW)
+	{
+	  kolibri_handle_event_redraw(main_window);
+	  kmainmenu_draw(main_menu);
+	  draw_bitmap(image_data_rgb, 5, 60, 400, 250);
+	}
+      else if(gui_event == KOLIBRI_EVENT_KEY)
+	{
+	  key = get_key();
+	  kolibri_handle_event_key(main_window);
+	}
+      else if(gui_event == KOLIBRI_EVENT_BUTTON)
+	{
+	  unsigned int pressed_button = kolibri_button_get_identifier();
+	  switch (pressed_button)
+	  {
+	      case 0x00000001:
+			kolibri_exit();
+			break;
+		  case 110:
+		    if(checkbox -> flags & CHECKBOX_IS_SET) debug_board_write_str("Open\n");
+		    break;
+		  case 111:
+		    if(checkbox -> flags & CHECKBOX_IS_SET) debug_board_write_str("Save\n");
+		    break;
+		  case 113:
+		    if(checkbox -> flags & CHECKBOX_IS_SET) debug_board_write_str("Exit\n");
+		    kolibri_exit();
+		    break;
+		  case 120:
+		    if(checkbox -> flags & CHECKBOX_IS_SET) debug_board_write_str("Vertical flip\n");
+		    img_flip(image_data, 0x01);
+		    img_to_rgb2(image_data, image_data_rgb);
+		    draw_bitmap(image_data_rgb, 5, 30, 400, 250);
+		    break;
+		  case 121:
+		    if(checkbox -> flags & CHECKBOX_IS_SET) debug_board_write_str("Horizontal flip\n");
+		    img_flip(image_data, 0x02);
+		    img_to_rgb2(image_data, image_data_rgb);
+		    draw_bitmap(image_data_rgb, 5, 30, 400, 250);
+		    break;
+	  }
+	 }
+      else if(gui_event == KOLIBRI_EVENT_MOUSE)
+	{
+	  kolibri_handle_event_mouse(main_window);
+	  kmainmenu_dispatch_cursorevent(main_menu);
+	}
+
+    } while(gui_event = get_os_event()); /* End of main activity loop */
+
+  /* kolibri_quit(); */
+
+  return 0;
+}

contrib/C_Layer/Example/Example_C/kolibri_boxlib.h

@@ -0,0 +1,18 @@
+#ifndef KOLIBRI_BOXLIB_H
+#define KOLIBRI_BOXLIB_H
+
+extern int init_boxlib_asm(void); 
+
+int kolibri_boxlib_init(void)
+{
+  int asm_init_status = init_boxlib_asm();
+  
+  /* just return asm_init_status? or return init_boxlib_asm() ?*/
+
+  if(asm_init_status == 0)
+    return 0;
+  else
+    return 1;
+}
+
+#endif /* KOLIBRI_BOXLIB_H */

contrib/C_Layer/Example/Example_C/kolibri_button.h

@@ -0,0 +1,47 @@
+#ifndef KOLIBRI_BUTTON_H
+#define KOLIBRI_BUTTON_H
+
+struct kolibri_button {
+  unsigned int x65536sizex;
+  unsigned int y65536sizey;
+  unsigned int color;
+  unsigned int identifier;
+  unsigned int XY;
+};
+
+struct kolibri_button *kolibri_new_button(unsigned int tlx, unsigned int tly, unsigned int sizex, unsigned int sizey,
+					  unsigned int identifier, unsigned int color)
+{
+  struct kolibri_button* new_button = (struct kolibri_button *)malloc(sizeof(struct kolibri_button));
+  new_button -> x65536sizex = (tlx << 16) + sizex;
+  new_button -> y65536sizey = (tly << 16) + sizey;
+  new_button -> color = color;
+  new_button -> identifier = identifier;
+  new_button -> XY = 0;
+  return new_button;
+}
+
+void draw_button(struct kolibri_button *some_button)
+{
+  define_button(some_button -> x65536sizex, some_button -> y65536sizey, some_button -> identifier, some_button -> color);
+}
+
+unsigned int kolibri_button_get_identifier(void)
+{
+  unsigned int identifier;
+
+  __asm__ __volatile__(
+		       "int $0x40"
+		       :"=a"(identifier)
+		       :"a"(17)
+		       );
+  /* If no button pressed, returns 1 */
+  /* Otherwise, returns identifier of button */
+
+  if(identifier != 1) /* Button was detected indeed */
+    return identifier>>8;
+  else
+    return identifier; /* No button detected */
+}
+
+#endif /* KOLIBRI_BUTTON_H */

contrib/C_Layer/Example/Example_C/kolibri_checkbox.h

@@ -0,0 +1,43 @@
+#ifndef KOLIBRI_CHECKBOX_H
+#define KOLIBRI_CHECKBOX_H
+
+#include "kolibri_colors.h"
+
+enum CHECKBOX_FLAGS {
+     CHECKBOX_IS_SET = 0x00000002
+     /* Add more flags later */
+};
+
+struct check_box {
+    unsigned int left_s;
+    unsigned int top_s;
+    unsigned int ch_text_margin;
+    unsigned int color;
+    unsigned int border_color;
+    unsigned int text_color;
+    char *text;
+    unsigned int flags;
+
+    /* Users can use members above this */
+    unsigned int size_of_str;
+};
+
+struct check_box* kolibri_new_check_box(unsigned int tlx, unsigned int tly, unsigned int sizex, unsigned int sizey, char *label_text)
+{
+     struct check_box* new_checkbox = (struct check_box *)malloc(sizeof(struct check_box));
+     new_checkbox -> left_s = (tlx << 16) + sizex;
+     new_checkbox -> top_s  = (tly << 16) + sizey;
+     new_checkbox -> ch_text_margin = 10;
+     new_checkbox -> color = 0xFFFFFFFF;
+     new_checkbox -> border_color = kolibri_color_table.color_work_graph;
+     new_checkbox -> text_color = kolibri_color_table.color_work_text;
+     new_checkbox -> text = label_text;
+     new_checkbox -> flags = 0x00000008;
+
+     return new_checkbox;
+}
+
+extern void (*check_box_draw2)(struct check_box *) __attribute__((__stdcall__));
+extern void (*check_box_mouse2)(struct check_box *)__attribute__((__stdcall__));
+
+#endif /* KOLIBRI_CHECKBOX_H */

contrib/C_Layer/Example/Example_C/kolibri_colors.h

@@ -0,0 +1,28 @@
+#ifndef KOLIBRI_COLORS_H
+#define KOLIBRI_COLORS_H
+struct kolibri_system_colors {
+  unsigned int color_frame_area;
+  unsigned int color_grab_bar;
+  unsigned int color_grab_bar_button;
+  unsigned int color_grab_button_text;
+  unsigned int color_grab_text;
+  unsigned int color_work_area;
+  unsigned int color_work_button;
+  unsigned int color_work_button_text;
+  unsigned int color_work_text;
+  unsigned int color_work_graph;
+};
+
+struct kolibri_system_colors kolibri_color_table;
+
+void kolibri_get_system_colors(struct kolibri_system_colors *color_table)
+{
+  __asm__ volatile ("int $0x40"
+		    :
+		    :"a"(48),"b"(3),"c"(color_table),"d"(40)
+		    );
+
+  /* color_table should point to the system color table */
+}
+
+#endif /* KOLIBRI_COLORS_H */

contrib/C_Layer/Example/Example_C/kolibri_debug.h

@@ -0,0 +1,36 @@
+#ifndef KOLIBRI_DEBUG_H
+#define KOLIBRI_DEBUG_H
+
+#include <_ansi.h>
+#include <reent.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+/* Write a printf() like function (variable argument list) for
+   writing to debug board */
+
+inline void debug_board_write_byte(const char ch){
+    __asm__ __volatile__(
+    "int $0x40"
+    :
+    :"a"(63), "b"(1), "c"(ch));
+}
+
+//added noninline because incofortabre stepping in in debugger
+void __attribute__ ((noinline)) debug_board_write_str(const char* str){
+  while(*str)
+    debug_board_write_byte(*str++);
+}
+
+void debug_board_printf(const char *format,...)
+{
+	va_list ap;
+	char log_board[300];
+	
+	va_start (ap, format);
+	vsprintf(log_board, format, ap);
+	va_end(ap);
+	debug_board_write_str(log_board);
+}
+
+#endif /* KOLIBRI_DEBUG_H */

contrib/C_Layer/Example/Example_C/kolibri_editbox.h

@@ -0,0 +1,89 @@
+#ifndef KOLIBRI_EDITBOX_H
+#define KOLIBRI_EDITBOX_H
+
+#include "kolibri_colors.h"
+
+struct edit_box {
+  unsigned int width; 
+    unsigned int left;
+    unsigned int top; 
+    unsigned int color; 
+    unsigned int shift_color; 
+    unsigned int focus_border_color; 
+    unsigned int blur_border_color;
+    unsigned int text_color;
+    unsigned int max;
+    char *text;
+    unsigned int mouse_variable;
+    unsigned int flags;
+
+/* The following struct members are not used by the users of API */
+    unsigned int size;
+    unsigned int pos;
+    unsigned int offset;
+    unsigned int cl_curs_x;
+    unsigned int cl_curs_y;
+    unsigned int shift;
+    unsigned int shift_old;
+};
+
+/* Initializes an Editbox with sane settings, sufficient for most use. 
+   This will let you create a box and position it somewhere on the screen. 
+   The text_buffer is a pointer to a character array and needs to be as long as 
+   AT LEAST MAX_CHARS + 1.If the text_buffer is smaller, it will crash if user 
+   types more characters than what will fit into the text buffer.
+
+   Allocating buffer space automatically so that programmer can be carefree now.
+   This also automatically adjusts the size of edit box so that it can hold enough characters.
+
+   All you need is : 
+
+   tlx,tly = Coordinates of the beginning of the edit box. 
+   max_chars = Limit of number of characters user can enter into edit box.
+*/
+
+struct edit_box* kolibri_new_edit_box(unsigned int tlx, unsigned int tly, unsigned int max_chars)
+{
+    unsigned int PIXELS_PER_CHAR = 7;
+    struct edit_box *new_textbox = (struct edit_box *)malloc(sizeof(struct edit_box));
+    char *text_buffer = (char *)calloc(max_chars + 1, sizeof(char));
+
+    /* Update blur_border_color and shift_color from box_lib.mac macro */
+    /* edit_boxes_set_sys_color */
+
+    new_textbox -> width = max_chars * PIXELS_PER_CHAR;
+    new_textbox -> left = tlx;
+    new_textbox -> top = tly; 
+    new_textbox -> color = 0xFFFFFF; /* Always make white edit boxes */
+    new_textbox -> shift_color = 0x6a9480; 
+    new_textbox -> focus_border_color = kolibri_color_table.color_work_graph; 
+    new_textbox -> blur_border_color = 0x6a9480;
+    new_textbox -> text_color = kolibri_color_table.color_work_text; /* Always black text when typing */
+    new_textbox -> max = max_chars;
+    new_textbox -> text = text_buffer;
+    new_textbox -> mouse_variable = 1; /* let the mouse take control? */
+    new_textbox -> flags = 0x00000000;
+    /* If these lines are uncommented, the executable will crash for no reason at start */
+    /* Even though these lines are not ever read it ALWAYS causes a crash, even crashes MTDBG. What gives? */
+
+    new_textbox -> size = 0;
+    new_textbox -> pos = 0;
+    new_textbox -> offset = 0;
+    new_textbox -> cl_curs_x = 0;
+    new_textbox -> cl_curs_y = 0;
+    new_textbox -> shift = 0;
+    new_textbox -> shift_old = 0;
+
+    return new_textbox;
+}
+
+extern void (*edit_box_draw)(struct edit_box *) __attribute__((__stdcall__));
+
+/* editbox_key is a wrapper written in assembly to handle key press events for editboxes */
+/* because inline assembly in GCC is a PITA and interferes with the EAX (AH) register */
+/* which edit_box_key requires */
+extern void editbox_key(struct edit_box *) __attribute__((__stdcall__));
+
+extern void (*edit_box_mouse)(struct edit_box *) __attribute__((__stdcall__));
+extern volatile unsigned press_key;
+#endif /* KOLIBRI_EDITBOX_H */

contrib/C_Layer/Example/Example_C/kolibri_frame.h

@@ -0,0 +1,48 @@
+#ifndef KOLIBRI_FRAME_H
+#define KOLIBRI_FRAME_H
+
+enum {
+	TOP,
+	BOTTON
+};
+
+struct frame {
+	unsigned int type;
+	uint16_t size_x;                  
+	uint16_t start_x;                 
+	uint16_t size_y;                  
+	uint16_t start_y;                
+	unsigned int ext_col;            
+	unsigned int int_col;            
+	unsigned int draw_text_flag;  
+	char *text_pointer;          
+	unsigned int text_position;   
+	unsigned int font_number;     
+	unsigned int font_size_y;           
+	unsigned int font_color;            
+	unsigned int font_backgr_color;
+}; 
+
+struct frame* kolibri_new_frame(uint16_t tlx, uint16_t tly, uint16_t sizex, uint16_t sizey, unsigned int ext_col, unsigned int int_col, unsigned int draw_text_flag, char *text_pointer, unsigned int text_position, unsigned int font_color, unsigned int font_bgcolor)
+{
+    struct frame *new_frame = (struct frame *)malloc(sizeof(struct frame));
+    new_frame -> type = 0;
+    new_frame -> size_x = sizex;               
+    new_frame -> start_x = tlx;              
+    new_frame -> size_y = sizey;               
+    new_frame -> start_y = tly;              
+    new_frame -> ext_col = ext_col;          
+    new_frame -> int_col = int_col;          
+    new_frame -> draw_text_flag = draw_text_flag;  
+    new_frame -> text_pointer = text_pointer;    
+    new_frame -> text_position = text_position;   
+    new_frame -> font_number = 1;     
+    new_frame -> font_size_y = 12;      
+    new_frame -> font_color = font_color;       
+    new_frame -> font_backgr_color = font_bgcolor;
+    return new_frame;
+}
+
+extern void (*frame_draw)(struct frame *) __attribute__((__stdcall__));
+
+#endif /* KOLIBRI_FRAME_H */

contrib/C_Layer/Example/Example_C/kolibri_gui.h

@@ -0,0 +1,134 @@
+#ifndef KOLIBRI_GUI_H
+#define KOLIBRI_GUI_H
+
+#include <stdlib.h> /* for malloc() */
+#include <kos32sys.h>
+
+#include "kolibri_debug.h" /* work with debug board */
+
+/* boxlib loader */
+#include "kolibri_boxlib.h"
+
+/* All supported GUI elements included */
+#include "kolibri_gui_elements.h"
+
+enum KOLIBRI_GUI_EVENTS {
+  KOLIBRI_EVENT_REDRAW = 1,   /* Window and window elements should be redrawn */
+  KOLIBRI_EVENT_KEY = 2,      /* A key on the keyboard was pressed */
+  KOLIBRI_EVENT_BUTTON = 3,   /* A button was clicked with the mouse */
+  KOLIBRI_EVENT_MOUSE = 6     /* Mouse activity (movement, button press) was detected */
+};
+
+void kolibri_handle_event_redraw(struct kolibri_window* some_window)
+{
+  /*  Draw windows with system color table. */
+
+  BeginDraw();
+
+  DrawWindow(some_window->topleftx, some_window->toplefty,
+	     some_window->sizex, some_window->sizey,
+	     some_window->window_title,
+	     kolibri_color_table.color_work_area, some_window->XY);
+
+  /* Enumerate and draw all window elements here */
+  if(some_window->elements) /* Draw all elements added to window */
+    {
+      struct kolibri_window_element* current_element = some_window -> elements;
+
+      do
+	{
+	  /* The redraw_fn serves as draw_fn on initial draw */
+	  if(kolibri_gui_op_table[current_element -> type].redraw_fn)
+	    kolibri_gui_op_table[current_element -> type].redraw_fn(current_element -> element);
+
+//sie after fixing calling conventions no more needed
+/*
+	  switch(current_element -> type)
+	    {
+	    case KOLIBRI_EDIT_BOX:
+	    case KOLIBRI_CHECK_BOX:
+	      __asm__ volatile("push $0x13371337"::); / * Random value pushed to balance stack * /
+						      / * otherwise edit_box_draw leaves stack unbalanced * /
+						      / * and GCC jumps like a crazy motha' fucka' * /
+
+	      break;
+	    }
+*/
+	  current_element = current_element -> next;
+
+	} while(current_element != some_window->elements); /* Have we covered all elements? */
+    }
+}
+
+void kolibri_handle_event_key(struct kolibri_window* some_window)
+{
+  /* Enumerate and trigger key handling functions of window elements here */
+  if(some_window->elements)
+    {
+      struct kolibri_window_element *current_element = some_window -> elements;
+
+      do
+	{
+	  /* Only execute if the function pointer isn't NULL */
+	  if(kolibri_gui_op_table[current_element -> type].key_fn)
+	    kolibri_gui_op_table[current_element -> type].key_fn(current_element -> element);
+
+	  current_element = current_element -> next;
+	} while(current_element != some_window->elements); /* Have we covered all elements? */
+    }
+}
+
+void kolibri_handle_event_mouse(struct kolibri_window* some_window)
+{
+  /* Enumerate and trigger mouse handling functions of window elements here */
+  if(some_window->elements)
+    {
+      struct kolibri_window_element *current_element = some_window -> elements;
+
+      do
+	{
+	  if(kolibri_gui_op_table[current_element -> type].mouse_fn)
+	    kolibri_gui_op_table[current_element -> type].mouse_fn(current_element -> element);
+
+	  current_element = current_element -> next;
+
+	} while(current_element != some_window->elements); /* Have we covered all elements? */
+    }
+}
+
+void kolibri_exit(void)
+{
+  __asm__ volatile ("int $0x40"::"a"(-1));
+}
+
+int kolibri_gui_init(void)
+{
+  int boxlib_init_status = kolibri_boxlib_init();
+
+  if(boxlib_init_status == 0)
+    debug_board_write_str("ashmew2 is happy: Kolibri GUI Successfully Initialized.\n");
+  else
+    {
+      debug_board_write_str("ashmew2 is sad: Kolibri GUI Failed to initialize.\n");
+      kolibri_exit();
+    }
+
+  /* Initialize the global operation table which handles event functions of */
+  /* each individual element type */
+  kolibri_init_gui_op_table();
+
+  /* Get the current color table for Kolibri and store in global table*/
+  kolibri_get_system_colors(&kolibri_color_table);
+
+  /* Set up system events for buttons, mouse and keyboard and redraw */
+  /* Also set filters so that window receives mouse events only when active
+     and mouse inside window */
+  __asm__ volatile("int $0x40"::"a"(40), "b"(0xC0000027));
+
+  return boxlib_init_status;
+}
+
+/* Note: The current implementation tries to automatically colors
+   GUI elements with system theme */
+
+#endif /* KOLIBRI_GUI_H */

contrib/C_Layer/Example/Example_C/kolibri_gui_elements.h

@@ -0,0 +1,142 @@
+#ifndef KOLIBRI_GUI_ELEMENTS_H
+#define KOLIBRI_GUI_ELEMENTS_H
+
+/* GUI Elements being used */
+#include "kolibri_editbox.h"
+#include "kolibri_checkbox.h"
+#include "kolibri_button.h"
+#include "kolibri_progressbar.h"
+#include "kolibri_frame.h"
+
+/* enum KOLIBRI_GUI_ELEMENT_TYPE contains all available GUI items from box_lib */
+/* More elements can be added from other libraries as required */
+enum KOLIBRI_GUI_ELEMENT_TYPE {
+  KOLIBRI_EDIT_BOX,
+  KOLIBRI_CHECK_BOX,
+  KOLIBRI_RADIO_BUTTON,
+  KOLIBRI_SCROLL_BAR,
+  KOLIBRI_DYNAMIC_BUTTON,
+  KOLIBRI_MENU_BAR,
+  KOLIBRI_FILE_BROWSER,
+  KOLIBRI_TREE_LIST,
+  KOLIBRI_PATH_SHOW,
+  KOLIBRI_TEXT_EDITOR,
+  KOLIBRI_FRAME,
+  KOLIBRI_PROGRESS_BAR,
+
+  KOLIBRI_BUTTON,
+
+  /* Add elements above this element in order to let KOLIBRI_NUM_GUI_ELEMENTS */
+  /* stay at correct value */
+
+  KOLIBRI_NUM_GUI_ELEMENTS
+};
+
+/* Linked list which connects together all the elements drawn inside a GUI window */
+struct kolibri_window_element {
+  enum KOLIBRI_GUI_ELEMENT_TYPE type;
+  void *element;
+  struct kolibri_window_element *next, *prev;
+};
+
+
+typedef void (*cb_elem_boxlib)(void *) __attribute__((__stdcall__));
+
+/* Generic structure for supporting functions on various elements of Kolibri's GUI */
+struct kolibri_element_operations {
+ 	cb_elem_boxlib 	redraw_fn;
+ 	cb_elem_boxlib 	mouse_fn;
+ 	cb_elem_boxlib 	key_fn;
+};
+
+/* Structure for a GUI Window on Kolibri. It also contains all the elements drawn in window */
+struct kolibri_window {
+  unsigned int topleftx, toplefty;
+  unsigned int sizex, sizey;
+  char *window_title;
+
+  /* Refer to sysfuncs, value to be stored in EDX (Function 0) */
+  unsigned int XY;
+
+  struct kolibri_window_element *elements;
+};
+
+/*---------------------End of Structure and enum definitions---------------*/
+/*---------------------Define various functions for initializing GUI-------*/
+
+/* Master table containing operations for various GUI elements in one place */
+struct kolibri_element_operations kolibri_gui_op_table[KOLIBRI_NUM_GUI_ELEMENTS];
+
+void kolibri_init_gui_op_table(void)
+{
+/* Setting up functions for edit box GUI elements*/
+kolibri_gui_op_table[KOLIBRI_EDIT_BOX].redraw_fn = (cb_elem_boxlib)edit_box_draw;
+kolibri_gui_op_table[KOLIBRI_EDIT_BOX].mouse_fn = (cb_elem_boxlib)edit_box_mouse;
+kolibri_gui_op_table[KOLIBRI_EDIT_BOX].key_fn = (cb_elem_boxlib)editbox_key;
+
+/* Setting up functions for check box GUI elements*/
+kolibri_gui_op_table[KOLIBRI_CHECK_BOX].redraw_fn = (cb_elem_boxlib)check_box_draw2;
+kolibri_gui_op_table[KOLIBRI_CHECK_BOX].mouse_fn = (cb_elem_boxlib)check_box_mouse2;
+kolibri_gui_op_table[KOLIBRI_CHECK_BOX].key_fn = NULL;
+
+/* Setting up functions for Kolibri Buttons ( SysFunc 8 )*/
+kolibri_gui_op_table[KOLIBRI_BUTTON].redraw_fn = (cb_elem_boxlib)draw_button;
+kolibri_gui_op_table[KOLIBRI_BUTTON].mouse_fn = NULL;
+kolibri_gui_op_table[KOLIBRI_BUTTON].key_fn = NULL;
+
+/* Setting up functions for progress bar GUI elements*/
+kolibri_gui_op_table[KOLIBRI_PROGRESS_BAR].redraw_fn = (cb_elem_boxlib)progressbar_draw;
+kolibri_gui_op_table[KOLIBRI_PROGRESS_BAR].mouse_fn = NULL;
+kolibri_gui_op_table[KOLIBRI_PROGRESS_BAR].key_fn = NULL;
+
+/* Setting up functions for frame GUI elements*/
+kolibri_gui_op_table[KOLIBRI_FRAME].redraw_fn = (cb_elem_boxlib)frame_draw;
+kolibri_gui_op_table[KOLIBRI_FRAME].mouse_fn = NULL;
+kolibri_gui_op_table[KOLIBRI_FRAME].key_fn = NULL;
+
+}
+
+/* Create a new main GUI window for KolibriOS */
+/* tl stands for TOP LEFT. x and y are coordinates. */
+
+struct kolibri_window * kolibri_new_window(int tlx, int tly, int sizex, int sizey, char *title)
+{
+  struct kolibri_window *new_win = (struct kolibri_window *)malloc(sizeof(struct kolibri_window));
+
+  new_win->topleftx = tlx;
+  new_win->toplefty = tly;
+  new_win->sizex = sizex;
+  new_win->sizey = sizey;
+  new_win->window_title = title;
+  new_win->XY = 0x00000034; /* All windows are skinned windows with caption for now */
+  new_win->elements = NULL;
+
+  return new_win;
+}
+
+/* Add an element to an existing window */
+void kolibri_window_add_element(struct kolibri_window *some_window, enum KOLIBRI_GUI_ELEMENT_TYPE element_type, void *some_gui_element)
+{
+  struct kolibri_window_element *new_element = (struct kolibri_window_element *)malloc(sizeof(struct kolibri_window_element));
+
+  new_element -> type = element_type;
+  new_element -> element = some_gui_element;
+
+  if(!(some_window->elements)) /* No elements in window yet */
+    {
+      some_window->elements = new_element;
+      some_window->elements -> prev = some_window->elements;
+      some_window->elements -> next = some_window->elements;
+    }
+  else
+    {
+      struct kolibri_window_element *last_element = some_window -> elements -> prev;
+
+      last_element -> next = new_element;
+      new_element -> next = some_window -> elements; /* start of linked list  */
+      some_window -> elements -> prev = new_element;
+      new_element -> prev = last_element;
+    }
+}
+
+#endif /* KOLIBRI_GUI_ELEMENTS_H */

contrib/C_Layer/Example/Example_C/kolibri_kmenu.h

@@ -0,0 +1,28 @@
+#ifndef KOLIBRI_KMENU_H
+#define KOLIBRI_KMENU_H
+
+extern int init_kmenu_asm(void); 
+
+int kolibri_kmenu_init(void)
+{
+  int asm_init_status = init_kmenu_asm();
+  
+  /* just return asm_init_status? or return init_boxlib_asm() ?*/
+
+  if(asm_init_status == 0)
+    return 0;
+  else
+    return 1;
+}
+
+
+
+extern void (*kmainmenu_draw)(void *) __attribute__((__stdcall__));
+extern void (*kmainmenu_dispatch_cursorevent)(void *) __attribute__((__stdcall__));
+extern void (*kmenu_init)(void *) __attribute__((__stdcall__));
+extern void* (*ksubmenu_new)() __attribute__((__stdcall__));
+extern void (*ksubmenu_add)(void *, void *) __attribute__((__stdcall__));
+extern void* (*kmenuitem_new)(uint32_t, const char *, uint32_t) __attribute__((__stdcall__));
+extern void* (*kmenuitem__submenu_new)(uint32_t, const char *, void *) __attribute__((__stdcall__));
+
+#endif /* KOLIBRI_KMENU_H */

contrib/C_Layer/Example/Example_C/kolibri_libimg.h

@@ -0,0 +1,30 @@
+#ifndef KOLIBRI_LIBIMG_H
+#define KOLIBRI_LIBIMG_H
+
+int kolibri_libimg_init(void)
+{
+  int asm_init_status = init_libimg_asm();
+  
+  /* just return asm_init_status? or return init_libimg_asm() ?*/
+
+  if(asm_init_status == 0)
+    return 0;
+  else
+    return 1;
+}
+
+extern void* (*img_decode)(void *, uint32_t, uint32_t) __attribute__((__stdcall__));
+extern void* (*img_encode)(void *, uint32_t, uint32_t) __attribute__((__stdcall__));
+extern void* (*img_create)(uint32_t, uint32_t, uint32_t) __attribute__((__stdcall__));
+extern void (*img_to_rgb2)(void *, void *) __attribute__((__stdcall__));
+extern void* (*img_to_rgb)(void *) __attribute__((__stdcall__));
+extern uint32_t (*img_flip)(void *, uint32_t) __attribute__((__stdcall__));
+extern uint32_t (*img_flip_layer)(void *, uint32_t) __attribute__((__stdcall__));
+extern uint32_t (*img_rotate)(void *, uint32_t) __attribute__((__stdcall__));
+extern uint32_t (*img_rotate_layer)(void *, uint32_t) __attribute__((__stdcall__));
+extern void (*img_draw)(void *, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t	) __attribute__((__stdcall__));
+extern uint32_t (*img_count)(void *) __attribute__((__stdcall__));
+extern uint32_t (*img_destroy)(void *) __attribute__((__stdcall__));
+extern uint32_t (*img_destroy_layer)(void *) __attribute__((__stdcall__));
+
+#endif /* KOLIBRI_LIBIMG_H */

contrib/C_Layer/Example/Example_C/kolibri_progressbar.h

@@ -0,0 +1,39 @@
+#ifndef KOLIBRI_PROGRESSBAR_H
+#define KOLIBRI_PROGRESSBAR_H
+
+struct progress_bar {
+	unsigned int value; 
+    unsigned int left;
+    unsigned int top; 
+    unsigned int width; 
+    unsigned int height; 
+    unsigned int style; 
+    unsigned int min;
+    unsigned int max;
+    unsigned int back_color;
+    unsigned int progress_color;
+    unsigned int frame_color;
+};
+
+struct progress_bar* kolibri_new_progress_bar(unsigned int min_value, unsigned int max_value, unsigned int cur_value, unsigned int tlx, unsigned int tly, unsigned int sizex, unsigned int sizey)
+{
+    struct progress_bar *new_progressbar = (struct progress_bar *)malloc(sizeof(struct progress_bar));
+    
+    new_progressbar -> value = cur_value; 
+    new_progressbar -> left = tlx;
+    new_progressbar -> top = tly; 
+    new_progressbar -> width = sizex; 
+    new_progressbar -> height = sizey; 
+    new_progressbar -> style = 1; 
+    new_progressbar -> min = min_value;
+    new_progressbar -> max = max_value;
+    new_progressbar -> back_color = 0xffffff;
+    new_progressbar -> progress_color = 0x00ff00;
+    new_progressbar -> frame_color = 0x000000;
+    return new_progressbar;
+}
+
+extern void (*progressbar_draw)(struct progress_bar *) __attribute__((__stdcall__));
+extern void (*progressbar_progress)(struct progress_bar *) __attribute__((__stdcall__));
+
+#endif /* KOLIBRI_PROGRESSBAR_H */

contrib/C_Layer/Example/Example_C/kolwin.c

@@ -0,0 +1,57 @@
+#include "kolibri_gui.h"
+
+int main()
+{
+  /* Load all libraries, initialize global tables like system color table and 
+     operations table. kolibri_gui_init() will EXIT with mcall -1 if it fails
+     to do it's job. This is all you need to call and all libraries and GUI
+     elements can be used after a successful call to this function
+  */
+  kolibri_gui_init();
+
+  /* Set gui_event to REDRAW so that window is drawn in first iteration  */
+  unsigned int gui_event = KOLIBRI_EVENT_REDRAW;
+
+  struct kolibri_window *main_window = kolibri_new_window(50, 50, 400, 100, "BoardMsg: Send msg to debug board");
+  struct check_box *checkbox = kolibri_new_check_box(20, 40, 12, 12, "Append BOARDMSG to entered message.");
+  struct edit_box *textbox = kolibri_new_edit_box(20, 55, 40);
+  struct kolibri_button *button = kolibri_new_button(310, 55, 14, 14, 0x00123456, kolibri_color_table.color_work_button);
+
+  kolibri_window_add_element(main_window, KOLIBRI_EDIT_BOX, textbox);
+  kolibri_window_add_element(main_window, KOLIBRI_CHECK_BOX, checkbox);
+  kolibri_window_add_element(main_window, KOLIBRI_BUTTON, button);
+
+  do  /* Start of main activity loop */
+    {
+      if(gui_event == KOLIBRI_EVENT_REDRAW)
+	{
+	  kolibri_handle_event_redraw(main_window);
+	}
+      else if(gui_event == KOLIBRI_EVENT_KEY)
+	{
+	  kolibri_handle_event_key(main_window);
+	}
+      else if(gui_event == KOLIBRI_EVENT_BUTTON)
+	{
+	  unsigned int pressed_button = kolibri_button_get_identifier();
+
+	  if(pressed_button = 0x00123456) /* Our button was pressed */
+	    {
+	      if(checkbox -> flags & CHECKBOX_IS_SET) /* Append BoardMsg checkbox is set */
+		debug_board_write_str("BOARDMSG: ");
+
+	      debug_board_write_str(textbox->text);
+	      debug_board_write_str("\n");
+	    }
+	}
+      else if(gui_event == KOLIBRI_EVENT_MOUSE)
+	{
+	  kolibri_handle_event_mouse(main_window);
+	}
+
+    } while(gui_event = get_os_event()); /* End of main activity loop */
+
+  /* kolibri_quit(); */
+
+  return 0;
+}

contrib/C_Layer/Example/Example_C/loadboxlib.asm

@@ -0,0 +1,141 @@
+format coff
+use32                                   ; Tell compiler to use 32 bit instructions
+
+section '.init' code			; Keep this line before includes or GCC messes up call addresses
+
+include '../../../programs/proc32.inc'
+include '../../../programs/macros.inc'
+purge section,mov,add,sub
+	
+include '../../../programs/develop/libraries/box_lib/trunk/box_lib.mac'
+include '../../../programs/system/run/trunk/txtbut.inc'
+include '../../../programs/dll.inc'
+	
+public init_boxlib as '_init_boxlib_asm'
+public editbox_key as '_editbox_key@4'
+public press_key as '_press_key'
+;;; Returns 0 on success. -1 on failure.
+
+proc init_boxlib
+	
+	mcall 68,11
+	
+	stdcall dll.Load, @IMPORT
+        test    eax, eax
+        jnz     error
+	
+	mov eax, 0
+	ret
+	
+error:	
+	mov eax, -1
+	ret
+endp	
+	
+;; Wrapper to handle edit_box_key function for editboxes.
+;; Call this baby from C (refer kolibri_editbox.h for details)
+editbox_key:
+	mov [oldebp], ebp	;Save ebp because GCC is crazy for it otherwise.
+	pop ebp			;Save return address in ebp. Stack top is param now.
+	mov eax, dword [press_key]
+	call [edit_box_key]	; The pointer we passed should be on the stack already.
+	push ebp		;push the return address back to stack
+	mov ebp, [oldebp]
+	ret
+	
+oldebp dd ?
+press_key dd ?
+
+@IMPORT:
+library lib_boxlib, 	'box_lib.obj'
+
+import lib_boxlib, \
+	edit_box_draw, 'edit_box' , \
+	edit_box_key, 'edit_box_key' , \
+	edit_box_mouse, 'edit_box_mouse', \
+	edit_box_set_text, 'edit_box_set_text' , \
+	init_checkbox2,  'init_checkbox2' , \
+	check_box_draw2, 'check_box_draw2' , \
+	check_box_mouse2, 'check_box_mouse2' , \
+	option_box_draw,  'option_box_draw' , \
+	option_box_mouse, 'option_box_mouse' , \
+	scroll_bar_vertical_draw, 'scrollbar_ver_draw' , \
+	scroll_bar_vertical_mouse, 'scrollbar_ver_mouse' , \
+	scroll_bar_horizontal_draw, 'scrollbar_hor_draw' , \
+	scroll_bar_horizontal_mouse, 'scrollbar_hor_mouse' , \
+	dinamic_button_draw, 'dbutton_draw' , \
+	dinamic_button_mouse, 'dbutton_mouse' , \
+	menu_bar_draw, 'menu_bar_draw' , \
+	menu_bar_mouse, 'menu_bar_mouse' , \
+	menu_bar_activate, 'menu_bar_activate' , \
+	fb_draw_panel, 'filebrowser_draw' , \
+	fb_mouse, 'filebrowser_mouse' , \
+	fb_key, 'filebrowser_key' , \
+	tl_data_init, 'tl_data_init' , \
+	tl_data_clear, 'tl_data_clear' , \
+	tl_info_clear, 'tl_info_clear' , \
+	tl_key, 'tl_key' , \
+	tl_mouse, 'tl_mouse' , \
+	tl_draw, 'tl_draw' , \
+	tl_info_undo, 'tl_info_undo' , \
+	tl_info_redo, 'tl_info_redo' , \
+	tl_node_add, 'tl_node_add' , \
+	tl_node_set_data, 'tl_node_set_data' , \
+	tl_node_get_data, 'tl_node_get_data' , \
+	tl_node_delete, 'tl_node_delete' , \
+	tl_cur_beg, 'tl_cur_beg' , \
+	tl_cur_next, 'tl_cur_next' , \
+	tl_cur_perv, 'tl_cur_perv' , \
+	tl_node_close_open, 'tl_node_close_open' , \
+	tl_node_lev_inc, 'tl_node_lev_inc' , \
+	tl_node_lev_dec, 'tl_node_lev_dec' , \
+	tl_node_move_up, 'tl_node_move_up' , \
+	tl_node_move_down, 'tl_node_move_down' , \
+	tl_node_poi_get_info, 'tl_node_poi_get_info' , \
+	tl_node_poi_get_next_info, 'tl_node_poi_get_next_info' , \
+	tl_node_poi_get_data, 'tl_node_poi_get_data' , \
+	tl_save_mem, 'tl_save_mem' , \
+	tl_load_mem, 'tl_load_mem' , \
+	tl_get_mem_size, 'tl_get_mem_size' , \
+	path_show_prepare, 'pathshow_prepare' , \
+	path_show_draw, 'pathshow_draw' , \
+	ted_but_sumb_upper, 'ted_but_sumb_upper' , \
+	ted_but_sumb_lover, 'ted_but_sumb_lover' , \
+	ted_but_convert_by_table, 'ted_but_convert_by_table' , \
+	ted_can_save, 'ted_can_save' , \
+	ted_clear, 'ted_clear' , \
+	ted_delete, 'ted_delete' , \
+	ted_draw, 'ted_draw' , \
+	ted_init, 'ted_init' , \
+	ted_init_scroll_bars, 'ted_init_scroll_bars' , \
+	ted_init_syntax_file, 'ted_init_syntax_file' , \
+	ted_is_select, 'ted_is_select' , \
+	ted_key, 'ted_key' , \
+	ted_mouse, 'ted_mouse' , \
+	ted_open_file, 'ted_open_file' , \
+	ted_save_file, 'ted_save_file' , \
+	ted_text_add, 'ted_text_add' , \
+	ted_but_select_word, 'ted_but_select_word' , \
+	ted_but_cut, 'ted_but_cut' , \
+	ted_but_copy, 'ted_but_copy' , \
+	ted_but_paste, 'ted_but_paste' , \
+	ted_but_undo, 'ted_but_undo' , \
+	ted_but_redo, 'ted_but_redo' , \
+	ted_but_reverse, 'ted_but_reverse' , \
+	ted_but_find_next, 'ted_but_find_next' , \
+	ted_text_colored, 'ted_text_colored' , \
+	frame_draw, 'frame_draw' , \
+	progressbar_draw,'progressbar_draw' , \
+	progressbar_progress, 'progressbar_progress'
+	
+public edit_box_draw as '_edit_box_draw'
+public edit_box_key as '_edit_box_key'
+public edit_box_mouse as '_edit_box_mouse'
+
+public check_box_draw2 as '_check_box_draw2'
+public check_box_mouse2 as '_check_box_mouse2'
+
+public progressbar_draw as '_progressbar_draw'
+public progressbar_progress as '_progressbar_progress'
+
+public frame_draw as '_frame_draw'

contrib/C_Layer/Example/Example_C/loadkmenu.asm

@@ -0,0 +1,68 @@
+format coff
+use32                                   ; Tell compiler to use 32 bit instructions
+
+section '.init' code			; Keep this line before includes or GCC messes up call addresses
+
+include '../../../programs/proc32.inc'
+include '../../../programs/macros.inc'
+purge section,mov,add,sub
+	
+include '../../../programs/dll.inc'
+	
+public init_kmenu as '_init_kmenu_asm'
+;;; Returns 0 on success. -1 on failure.
+
+proc init_kmenu
+	
+	mcall 68,11
+	
+	stdcall dll.Load, @IMPORT
+        test    eax, eax
+        jnz     error
+	
+	mov eax, 0
+	ret
+	
+error:	
+	mov eax, -1
+	ret
+endp	
+	
+@IMPORT:
+library lib_kmenu, 	'kmenu.obj'
+
+import lib_kmenu, \
+	kmainmenu_draw, 				 'kmainmenu_draw' , \
+	kmainmenu_dispatch_cursorevent,  'kmainmenu_dispatch_cursorevent' , \
+	kmainmenu_get_height, 			 'kmainmenu_get_height', \
+	ksubmenu_new, 					 'ksubmenu_new' , \
+	ksubmenu_delete,  				 'ksubmenu_delete' , \
+	ksubmenu_draw, 					 'ksubmenu_draw' , \
+	ksubmenu_add, 					 'ksubmenu_add' , \
+	ksubmenu_set_items_margin,  	 'ksubmenu_set_items_margin' , \
+	ksubmenu_set_items_padding, 	 'ksubmenu_set_items_padding' , \
+	kmenuitem_new, 					 'kmenuitem_new' , \
+	kmenuitem_delete, 				 'kmenuitem_delete' , \
+	kmenuitem_draw, 				 'kmenuitem_draw' , \
+	kmenuitem_get_preffered_width, 	 'kmenuitem_get_preffered_width' , \
+	kmenuitem_get_preffered_height,  'kmenuitem_get_preffered_height' , \
+	kmenu_set_font,					 'kmenu_set_font' , \
+	kmenu_init, 					 'kmenu_init'
+	
+public	kmainmenu_draw	 				 as '_kmainmenu_draw'
+public	kmainmenu_dispatch_cursorevent   as '_kmainmenu_dispatch_cursorevent'
+public	kmainmenu_get_height 			 as '_kmainmenu_get_height'
+public	ksubmenu_new 					 as '_ksubmenu_new'
+public	ksubmenu_delete  				 as '_ksubmenu_delete'
+public	ksubmenu_draw 					 as '_ksubmenu_draw'
+public	ksubmenu_add 					 as '_ksubmenu_add'
+public	ksubmenu_set_items_margin 	 	 as '_ksubmenu_set_items_margin'
+public	ksubmenu_set_items_padding  	 as '_ksubmenu_set_items_padding'
+public	kmenuitem_new					 as '_kmenuitem_new'
+public	kmenuitem_new					 as '_kmenuitem__submenu_new'
+public	kmenuitem_delete 				 as '_kmenuitem_delete'
+public	kmenuitem_draw  				 as '_kmenuitem_draw'
+public	kmenuitem_get_preffered_width 	 as '_kmenuitem_get_preffered_width'
+public	kmenuitem_get_preffered_height   as '_kmenuitem_get_preffered_height'
+public	kmenu_set_font					 as '_kmenu_set_font'
+public	kmenu_init 						 as '_kmenu_init'

contrib/C_Layer/Example/Example_C/loadlibimg.asm

@@ -0,0 +1,78 @@
+
+format coff
+use32                                   ; Tell compiler to use 32 bit instructions
+
+section '.init' code			; Keep this line before includes or GCC messes up call addresses
+
+include '../../../programs/proc32.inc'
+include '../../../programs/macros.inc'
+purge section,mov,add,sub
+	
+include '../../../programs/dll.inc'
+	
+public init_libimg as '_init_libimg_asm'
+;;; Returns 0 on success. -1 on failure.
+
+proc init_libimg
+	
+	mcall 68,11
+	
+	stdcall dll.Load, @IMPORT
+        test    eax, eax
+        jnz     error
+	
+	mov eax, 0
+	ret
+	
+error:	
+	mov eax, -1
+	ret
+endp	
+
+@IMPORT:
+library lib_libimg, 	'libimg.obj'
+
+import lib_libimg, \
+	libimg_init, 'lib_init' , \
+	img_is_img, 'img_is_img' , \
+	img_info, 'img_info' , \
+	img_from_file, 'img_from_file', \
+	img_to_file, 'img_to_file', \
+	img_from_rgb, 'img_from_rgb', \
+	img_to_rgb, 'img_to_rgb', \
+	img_to_rgb2, 'img_to_rgb2', \
+	img_decode, 'img_decode', \
+	img_encode, 'img_encode', \
+	img_create, 'img_create', \
+	img_destroy, 'img_destroy', \
+	img_destroy_layer, 'img_destroy_layer', \
+	img_count, 'img_count', \
+	img_lock_bits, 'img_lock_bits', \
+	img_unlock_bits, 'img_unlock_bits', \
+	img_flip, 'img_flip', \
+	img_flip_layer, 'img_flip_layer', \
+	img_rotate, 'img_rotate', \
+	img_rotate_layer, 'img_rotate_layer', \
+	img_draw, 'img_draw'
+	
+public libimg_init as  '_libimg_init'
+;	public img_is_img as  '_img_is_img'
+;public img_info as  '_img_info'
+;public img_from_file as  '_img_from_file'
+;public img_to_file as  '_img_to_file'
+;public img_from_rgb as  '_img_from_rgb'
+public img_to_rgb as  '_img_to_rgb'
+public img_to_rgb2 as  '_img_to_rgb2'
+public img_decode as  '_img_decode'
+public img_encode as  '_img_encode'
+public img_create as  '_img_create'
+public img_destroy as  '_img_destroy'
+public img_destroy_layer as  '_img_destroy_layer'
+public img_count as  '_img_count'
+;public img_lock_bits as  '_img_lock_bits'
+;public img_unlock_bits as  '_img_unlock_bits'
+public img_flip as  '_img_flip'
+public img_flip_layer as  '_img_flip_layer'
+public img_rotate as  '_img_rotate'
+public img_rotate_layer as  '_img_rotate_layer'
+public img_draw as  '_img_draw'

contrib/C_Layer/Example/Example_C/make_example_c.sh

@@ -0,0 +1,18 @@
+#Please set up kolibrios sources here : /home/<username>/kolibrios
+
+rm *.o
+rm *.obj
+rm *.map
+rm example_c
+
+kos32-gcc -c -I${HOME}/kolibrios/contrib/sdk/sources/newlib/libc/include -g -U_Win32 -U_WIN32 -U__MINGW32__ example_c.c -o example_c.o
+
+fasm loadboxlib.asm loadboxlib.obj
+fasm loadkmenu.asm loadkmenu.obj
+fasm loadlibimg.asm loadlibimg.obj
+
+kos32-ld *.o *.obj -T${HOME}/kolibrios/contrib/sdk/sources/newlib/libc/app.lds -nostdlib -static --image-base 0 -lgcc -L/home/autobuild/tools/win32/mingw32/lib /home/autobuild/tools/win32/lib/libdll.a /home/autobuild/tools/win32/lib/libapp.a /home/autobuild/tools/win32/lib/libc.dll.a -static -o example_c -Map=example_c.map
+
+objcopy -O binary example_c
+
+echo "If everything went well, boardxmsg should be your binary!"