/contrib/C_Layer/INCLUDE/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/INCLUDE/kolibri_buf2d.h |
---|
0,0 → 1,96 |
#ifndef KOLIBRI_BUF2D_H |
#define KOLIBRI_BUF2D_H |
/*ToDo |
* buf_curve_bezier |
* voxel function |
*/ |
extern int init_buf2d_asm(void); |
int kolibri_buf2d_init(void) |
{ |
int asm_init_status = init_buf2d_asm(); |
/* just return asm_init_status? or return init_boxlib_asm() ?*/ |
if(asm_init_status == 0) |
return 0; |
else |
return 1; |
} |
struct buf2d_struct { |
unsigned int *buf_pointer; |
uint16_t left; |
uint16_t top; |
unsigned int width; |
unsigned int height; |
unsigned int bgcolor; |
uint8_t color_bit; |
}; |
enum BUF2D_ALGORITM_FILTR { |
SIERRA_LITE, |
FLOYD_STEINBERG, |
BURKERS, |
HEAVYIRON_MOD, |
ATKINSON |
}; |
enum BUF2D_OPT_CROP { |
BUF2D_OPT_CROP_TOP = 1, |
BUF2D_OPT_CROP_LEFT = 2, |
BUF2D_OPT_CROP_BOTTOM = 4, |
BUF2D_OPT_CROP_RIGHT = 8 |
}; |
extern void (*buf2d_create_asm)(struct buf2d_struct *) __attribute__((__stdcall__)); |
extern void (*buf2d_curve_bezier_asm)(struct buf2d_struct *, unsigned int, unsigned int, unsigned int, unsigned int) __attribute__((__stdcall__)); |
struct buf2d_struct* buf2d_create(uint16_t tlx, uint16_t tly, unsigned int sizex, unsigned int sizey, unsigned int font_bgcolor, uint8_t color_bit) |
{ |
struct buf2d_struct *new_buf2d_struct = (struct buf2d_struct *)malloc(sizeof(struct buf2d_struct)); |
new_buf2d_struct -> left = tlx; |
new_buf2d_struct -> top = tly; |
new_buf2d_struct -> width = sizex; |
new_buf2d_struct -> height = sizey; |
new_buf2d_struct -> bgcolor = font_bgcolor; |
new_buf2d_struct -> color_bit = color_bit; |
buf2d_create_asm(new_buf2d_struct); |
return new_buf2d_struct; |
} |
void buf2d_curve_bezier(struct buf2d_struct *buf, unsigned int p0_x, unsigned int p0_y, unsigned int p1_x, unsigned int p1_y, unsigned int p2_x, unsigned int p2_y, unsigned int color) |
{ |
buf2d_curve_bezier_asm(buf, (p0_x<<16)+p0_y, (p1_x<<16)+p1_y, (p2_x<<16)+p2_y, color); |
} |
extern void (*buf2d_draw)(struct buf2d_struct *) __attribute__((__stdcall__)); |
extern void (*buf2d_clear)(struct buf2d_struct *, unsigned int) __attribute__((__stdcall__)); |
extern void (*buf2d_delete)(struct buf2d_struct *) __attribute__((__stdcall__)); |
extern void (*buf2d_rotate)(struct buf2d_struct *, unsigned int) __attribute__((__stdcall__)); |
extern void (*buf2d_resize)(struct buf2d_struct *, unsigned int, unsigned int, unsigned int) __attribute__((__stdcall__)); |
extern void (*buf2d_line)(struct buf2d_struct *, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int) __attribute__((__stdcall__)); |
extern void (*buf2d_line_sm)(struct buf2d_struct *, unsigned int, unsigned int, unsigned int, unsigned int) __attribute__((__stdcall__)); |
extern void (*buf2d_rect_by_size)(struct buf2d_struct *, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int) __attribute__((__stdcall__)); |
extern void (*buf2d_filled_rect_by_size)(struct buf2d_struct *, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int) __attribute__((__stdcall__)); |
extern void (*buf2d_circle)(struct buf2d_struct *, unsigned int, unsigned int, unsigned int, unsigned int) __attribute__((__stdcall__)); |
extern void (*buf2d_img_hdiv2)(struct buf2d_struct *) __attribute__((__stdcall__)); |
extern void (*buf2d_img_wdiv2)(struct buf2d_struct *) __attribute__((__stdcall__)); |
extern void (*buf2d_conv_24_to_8)(struct buf2d_struct *, unsigned int) __attribute__((__stdcall__)); |
extern void (*buf2d_conv_24_to_32)(struct buf2d_struct *, unsigned int) __attribute__((__stdcall__)); |
extern void (*buf2d_bit_blt_transp)(struct buf2d_struct *, unsigned int, unsigned int, struct buf2d_struct *) __attribute__((__stdcall__)); |
extern void (*buf2d_bit_blt_alpha)(struct buf2d_struct *, unsigned int, unsigned int, struct buf2d_struct *) __attribute__((__stdcall__)); |
extern void (*buf2d_convert_text_matrix)(struct buf2d_struct *) __attribute__((__stdcall__)); |
extern void (*buf2d_draw_text)(struct buf2d_struct *, struct buf2d_struct *, const char *, unsigned int, unsigned int) __attribute__((__stdcall__)); |
extern void (*buf2d_crop_color)(struct buf2d_struct *, unsigned int, unsigned int) __attribute__((__stdcall__)); |
extern void (*buf2d_offset_h)(struct buf2d_struct *, unsigned int, unsigned int, unsigned int) __attribute__((__stdcall__)); |
extern void (*buf2d_flood_fill)(struct buf2d_struct *, unsigned int, unsigned int, unsigned int, unsigned int) __attribute__((__stdcall__)); |
extern void (*buf2d_set_pixel)(struct buf2d_struct *, unsigned int, unsigned int, unsigned int) __attribute__((__stdcall__)); |
extern unsigned int (*buf2d_get_pixel)(struct buf2d_struct *, unsigned int, unsigned int) __attribute__((__stdcall__)); |
extern void (*buf2d_flip_h)(struct buf2d_struct *) __attribute__((__stdcall__)); |
extern void (*buf2d_flip_v)(struct buf2d_struct *) __attribute__((__stdcall__)); |
extern void (*buf2d_filter_dither)(struct buf2d_struct *, unsigned int) __attribute__((__stdcall__)); |
#endif /* KOLIBRI_BUF2D_H */ |
/contrib/C_Layer/INCLUDE/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/INCLUDE/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/INCLUDE/kolibri_colordialog.h |
---|
0,0 → 1,48 |
#ifndef KOLIBRI_COLORIALOG_H |
#define KOLIBRI_COLORIALOG_H |
char cd_com_area_name[] = "FFFFFFFF_color_dialog"; |
char cd_start_path[] = "/rd/1/colrdial"; |
struct color_dialog { |
unsigned int type; |
unsigned int procinfo; |
unsigned int com_area_name; |
unsigned int com_area; |
unsigned int start_path; |
unsigned int draw_window; |
unsigned int status; |
unsigned short x_size; |
unsigned short x_start; |
unsigned short y_size; |
unsigned short y_start; |
unsigned int color_type; |
unsigned int color; |
}; |
void cd_fake_on_redraw(void) {} |
struct open_dialog* kolibri_new_color_dialog(unsigned int type, unsigned short tlx, unsigned short tly, unsigned short x_size, unsigned short y_size) |
{ |
struct color_dialog *new_colordialog = (struct color_dialog *)malloc(sizeof(struct color_dialog)); |
char *proc_info = (char *)calloc(1024, sizeof(char)); |
new_colordialog -> type = type; |
new_colordialog -> procinfo = proc_info; |
new_colordialog -> com_area_name = &cd_com_area_name; |
new_colordialog -> com_area = 0; |
new_colordialog -> start_path = &cd_start_path; |
new_colordialog -> draw_window = &cd_fake_on_redraw; |
new_colordialog -> status = 0; |
new_colordialog -> x_size = x_size; |
new_colordialog -> x_start = tlx; |
new_colordialog -> y_size = y_size; |
new_colordialog -> y_start = tly; |
new_colordialog -> color_type = 0; |
new_colordialog -> color = 0; |
return new_colordialog; |
} |
extern void (*ColorDialog_init)(struct open_dialog *) __attribute__((__stdcall__)); |
extern void (*ColorDialog_start)(struct open_dialog *) __attribute__((__stdcall__)); |
#endif /* KOLIBRI_COLORDIALOG_H */ |
/contrib/C_Layer/INCLUDE/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/INCLUDE/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/INCLUDE/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/INCLUDE/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/INCLUDE/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/INCLUDE/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 = 0x00000013; /* 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/INCLUDE/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/INCLUDE/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/INCLUDE/kolibri_libini.h |
---|
0,0 → 1,29 |
#ifndef KOLIBRI_LIBINI_H |
#define KOLIBRI_LIBINI_H |
extern int init_libini_asm(void); |
int kolibri_libini_init(void) |
{ |
int asm_init_status = init_libini_asm(); |
/* just return asm_init_status? or return init_boxlib_asm() ?*/ |
if(asm_init_status == 0) |
return 0; |
else |
return 1; |
} |
extern uint32_t (*LIBINI_enum_sections)(const char*, void*) __attribute__((__stdcall__)); |
extern uint32_t (*LIBINI_enum_keys)(const char*, const char*, void*) __attribute__((__stdcall__)); |
extern uint32_t (*LIBINI_get_str)(const char*, const char*, const char*, char*, uint32_t) __attribute__((__stdcall__)); |
extern uint32_t (*LIBINI_set_str)(const char*, const char*, const char*, const char*, uint32_t) __attribute__((__stdcall__)); |
extern uint32_t (*LIBINI_get_int)(const char*, const char*, const char*, uint32_t) __attribute__((__stdcall__)); |
extern uint32_t (*LIBINI_set_int)(const char*, const char*, const char*, uint32_t) __attribute__((__stdcall__)); |
extern uint32_t (*LIBINI_get_color)(const char*, const char*, const char*, uint32_t) __attribute__((__stdcall__)); |
extern uint32_t (*LIBINI_set_color)(const char*, const char*, const char*, uint32_t) __attribute__((__stdcall__)); |
extern uint32_t (*LIBINI_get_shortcut)(const char*, const char*, const char*, uint32_t, const char*, uint32_t) __attribute__((__stdcall__)); |
#endif /* KOLIBRI_LIBINI_H */ |
/contrib/C_Layer/INCLUDE/kolibri_opendialog.h |
---|
0,0 → 1,67 |
#ifndef KOLIBRI_OPENDIALOG_H |
#define KOLIBRI_OPENDIALOG_H |
char sz_com_area_name[] = "FFFFFFFF_open_dialog"; |
char sz_dir_default_path[] = "/rd/1"; |
char sz_start_path[] = "/rd/1/File managers/opendial"; |
struct open_dialog { |
unsigned int mode; |
unsigned int procinfo; |
unsigned int com_area_name; |
unsigned int com_area; |
unsigned int opendir_path; |
unsigned int dir_default_path; |
unsigned int start_path; |
unsigned int draw_window; |
unsigned int status; |
unsigned int openfile_path; |
unsigned int filename_area; |
unsigned int filter_area; |
unsigned short x_size; |
unsigned short x_start; |
unsigned short y_size; |
unsigned short y_start; |
}; |
struct od_filter { |
unsigned int size; |
unsigned char end; |
}; |
void fake_on_redraw(void) {} |
struct open_dialog* kolibri_new_open_dialog(unsigned int mode, unsigned short tlx, unsigned short tly, unsigned short x_size, unsigned short y_size) |
{ |
struct open_dialog *new_opendialog = (struct open_dialog *)malloc(sizeof(struct open_dialog)); |
struct od_filter *new_od_filter = (struct od_filter *)malloc(sizeof(struct od_filter)); |
char *plugin_path = (char *)calloc(4096, sizeof(char)); |
char *openfile_path = (char *)calloc(4096, sizeof(char)); |
char *proc_info = (char *)calloc(1024, sizeof(char)); |
char *filename_area = (char *)calloc(256, sizeof(char)); |
new_od_filter -> size = 0; |
new_od_filter -> end = 0; |
new_opendialog -> mode = mode; |
new_opendialog -> procinfo = proc_info; |
new_opendialog -> com_area_name = &sz_com_area_name; |
new_opendialog -> com_area = 0; |
new_opendialog -> opendir_path = plugin_path; |
new_opendialog -> dir_default_path = &sz_dir_default_path; |
new_opendialog -> start_path = &sz_start_path; |
new_opendialog -> draw_window = &fake_on_redraw; |
new_opendialog -> status = 0; |
new_opendialog -> openfile_path = openfile_path; |
new_opendialog -> filename_area = filename_area; |
new_opendialog -> filter_area = new_od_filter; |
new_opendialog -> x_size = x_size; |
new_opendialog -> x_start = tlx; |
new_opendialog -> y_size = y_size; |
new_opendialog -> y_start = tly; |
return new_opendialog; |
} |
extern void (*OpenDialog_init)(struct open_dialog *) __attribute__((__stdcall__)); |
extern void (*OpenDialog_start)(struct open_dialog *) __attribute__((__stdcall__)); |
#endif /* KOLIBRI_OPENDIALOG_H */ |
/contrib/C_Layer/INCLUDE/kolibri_proclib.h |
---|
0,0 → 1,22 |
#ifndef KOLIBRI_PROCLIB_H |
#define KOLIBRI_PROCLIB_H |
int kolibri_proclib_init(void) |
{ |
int asm_init_status = init_proclib_asm(); |
/* just return asm_init_status? or return init_proclib_asm() ?*/ |
if(asm_init_status == 0) |
return 0; |
else |
return 1; |
} |
enum Mode { |
OD_OPEN, |
OD_SAVE, |
OD_DIR |
}; |
#endif /* KOLIBRI_PROCLIB_H */ |
/contrib/C_Layer/INCLUDE/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 */ |