XenOn/kolibrios-fun
1
1
Fork 0
forked from KolibriOS/kolibrios
Code Pull Requests Wiki Activity

add example

Browse Source 
git-svn-id: svn://kolibrios.org@6455 a494cfbc-eb01-0410-851d-a64ba20cac60
This commit is contained in:
Serhii Sakhno 2016-06-27 05:08:33 +00:00
parent 11f2e4b6a3
commit 294710dc20
19 changed files with 1149 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
contrib/C_Layer/Example/Example_C/111.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 197 KiB

105
contrib/C_Layer/Example/Example_C/example_c.c Normal file
View File

@ -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;
}

18
contrib/C_Layer/Example/Example_C/kolibri_boxlib.h Normal file
View File

@ -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 */

47
contrib/C_Layer/Example/Example_C/kolibri_button.h Normal file
View File

@ -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 */

43
contrib/C_Layer/Example/Example_C/kolibri_checkbox.h Normal file
View File

@ -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 */

28
contrib/C_Layer/Example/Example_C/kolibri_colors.h Normal file
View File

@ -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 */

36
contrib/C_Layer/Example/Example_C/kolibri_debug.h Normal file
View File

@ -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 */

89
contrib/C_Layer/Example/Example_C/kolibri_editbox.h Normal file
View File

@ -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 */

48
contrib/C_Layer/Example/Example_C/kolibri_frame.h Normal file
View File

@ -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 */

134
contrib/C_Layer/Example/Example_C/kolibri_gui.h Normal file
View File

@ -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 */

142
contrib/C_Layer/Example/Example_C/kolibri_gui_elements.h Normal file
View File

@ -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 */

28
contrib/C_Layer/Example/Example_C/kolibri_kmenu.h Normal file
View File

@ -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 */

30
contrib/C_Layer/Example/Example_C/kolibri_libimg.h Normal file
View File

@ -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 */

39
contrib/C_Layer/Example/Example_C/kolibri_progressbar.h Normal file
View File

@ -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 */

57
contrib/C_Layer/Example/Example_C/kolwin.c Normal file
View File

@ -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;
}

141
contrib/C_Layer/Example/Example_C/loadboxlib.asm Normal file
View File

@ -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'

68
contrib/C_Layer/Example/Example_C/loadkmenu.asm Normal file
View File

@ -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'

78
contrib/C_Layer/Example/Example_C/loadlibimg.asm Normal file
View File

@ -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'

18
contrib/C_Layer/Example/Example_C/make_example_c.sh Executable file
View File

@ -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!"