GNU Firmware is a sub draft EOS based on the source code of Linux, QEMU, VIRTUALBOX, BOCHS and OPENBIOS, it tries to be a replacement of similar programs grub and initialization of operating systems, such as XOSLD, it is an initiator operating systems fully configurable and with a graphical environment.
Although in this case only EOS start looking at any type of machine, regardless of architecture, which has, allowing to have a unified architecture for development. This would allow you to start a machine EOS PowerPC, SPARC, ARM, etc., without having to make changes in their programs or changes in the configuration of EOS.
GNU Firmware works starting their machine, loading all drivers and modules to operate all of its peripheral machine, and then sends the data to initialize kernel you want to give it "generic data" that will have the kernel to boot, this how you can get support multimedia, 3D acceleration, and other routines of his machine with optimal performance. And not only can configure GNU Firmware to initiate and install EOS, but may initiate other operating systems, and even do not have to restart your machine real way, because when you restart each system, the GNU Firmware this again, however may a real restart your computer or simply turn it off.


GNU Firmware Features


-- Accelerating 3d
-- Detection and installation hardware
-- Setup and installation of new operating systems simple
-- Creation of virtualized and memory units for virtualized operating systems
-- Support units particionacion
-- Protection of networks
-- Hub virtualized
-- Services pppd, ipx


Introduction to UNIX


UNIX is composed of three parts that make it functional, they apply equally in EOS.

1 - The Kernel:
Is that manages system resources (terminals, printers, disks, etc..).

2 - The File System: (file system)
Is that organizes data.

3 - The Shell:
It is a shell of UNIX. Although there is more than a utility, is the part that the user sees UNIX (the user interface).

It is believed to UNIX as an interactive system, multitasking (in every sense of the word) and multiuser; processes can be sent to many users at once.
Planning for the CPU becomes priorities by using an algorithm (although some versions as 4.2 BSD used a paging system on demand). This system is identical to the functioning of multitasking in EOS through paging on demand.

Introduction of EOS SCRIPT


Within EOS there are various forms of development, one of which is through SCRIPTS, the same source code are to be interpreted and permit applications, games and utilities, and it is even possible to develop drivers or external modules.
In EOS 3 systems may find that SCRIPT below describe as their usefulness and importance:

BASH
HTML JAVASCRIPT
FENIX

The language interpretation given by BASH allows small programs bacheo that allow you to configure your system, running various services as well as putting different environment variables, the system is generic and does not employ functions "general" EOS own, but a standardized UNIX.

The HTML-JAVASCRIPT is granted by the program BeLinks, it is web browser officer of EOS, where you can make a few small steps programmes for their system. They were developed from a plane in HTML language through classes and definitions specific to the HTML language, some observations are that this language SCRIPT has many limitations, the first figure is not entirely as it is a mixture of text with images , and on the other hand does not allow callers to develop applications without binaries "extension" so that you have to have registered all extensions to the time required to run an application.

FENIX The language is a more complex script, it works with 2 sides, a compiler and an interpreter. This language does not generate binary, but an intermediate code is then interpreted, and allow you to develop graphics applications, utilities, games and configurators 2d and 3d.
It is a very simple system development based on the language Pascal and C, which makes it very practical so that it can develop quickly in EOS, albeit a novice in the world of programming, allowing hear appeals UNIX and learn advanced programming. This language has no limitation, since even make it possible to expand bookstores domains, and even develop great games. Only limited to the use of a single code without compilation withstand multiple objects, however it is possible to have multiple inclusions codes external sources.


The Functions Primitives BE (BASIC EMULATION)


Within EOS will find primitive functions that are responsible for controlling all functions graphics and peripheral functions within EOS. Therefore with them can generate programs that use less memory, or are faster. As well may access the core of the system if he wanted to make changes, or put a task with greater dominance within another.
Within these functions will have available sources truetypes control, the control of images bmp, png and xpm, basic graphics routines (such as lines, vertices, squares, etc.), mora imeti routines hardware control (you can control the system exits on your keyboard, mouse or other peripheral), controls rendering (in the case that seeks to make visual effects), and alpha blending routine and collision detection (useful in the development of games).


PRIMITIVE FUNCTIONS


Within the graphics system found a number of headers (inclusions), which will detail below explaining their functions:

AppServer.h
Head to access functions within the server AppServer, utilicelas just in case you want to make changes in the administration of tasks, or graphics native of EOS, you can also use it if you want to improve or add new functions to the system server administration .

B.h
Head principal, allows access to all functions PRIMITIVE DESIGN, which allow to control functions KEYBOARD, RATON, VIDEO. And given the functions required for access to drawing functions, control areas, block detection, detection of collisions, search paths, writing on the screen (using truetype), features images (PNG, GIF, and xpm) functions networks (SOCKET, PIPE), functions sprites (PNG and XPM), cursor functions, features windows, scroll functions, and functions draw 2D. All functions are encapsulated in this EOS HEADER the same works in a similar way to Direct X, as it is based on providing services accelerated write on the screen, the more useful functions for the development of 2D video games, you may want to use higher profits SDL games if you want to get further development.

B_.h
Head functions that gives access to service customers via sockets provided by the AppServer allowing access features PIPE and SOCKET.

Helper.h
Head of the project which gives HYNTH functions native drivers for graphics, mouse and keyboard, are all the controls and functions necessary to make drivers alter functionality AppServer, or optimize.

Ini.h
Functions reading INI files in the style of Microsoft Windows, very helpful for the development of applications that can be configured by ini files, it is easier to use the functions of state ini owns header "Bh.

Mem.h
Functions control memory, allowing back segments and duplication of memory segments. Very useful for developers looking to optimize their programs or games.

Oskit.h
Functions Primitives drawing on the screen in C + + based on the codes of the project XYNTH.

Png.h
Head including the extension of PNG image, allows working with PNG image formats and coding of images, besides serving as the algorithm for development of graphics functions.

Pngconf.h
Functions configuration used by the PNG image format.


FUNCTIONS OF GRAPHS EOS (list and description of duties)


DEFINITION OF KEY


Then list all keys that provides support EOS, how to use them is calling them directly by the following variables:

B_KEY_ESCAPE,
B_KEY_ONE,
B_KEY_TWO,
B_KEY_THREE,
B_KEY_FOUR,
B_KEY_FIVE,
B_KEY_SIX,
B_KEY_SEVEN,
B_KEY_EIGHT,
B_KEY_NINE,
B_KEY_ZERO,
B_KEY_MINUS,
B_KEY_EQUAL,
B_KEY_DELETE,
B_KEY_TAB,
B_KEY_q,
B_KEY_w,
B_KEY_e,
B_KEY_r,
B_KEY_t,
B_KEY_y,
B_KEY_u,
B_KEY_i,
B_KEY_o,
B_KEY_p,
B_KEY_BRACKETLEFT,
B_KEY_BRACKETRIGHT,
B_KEY_RETURN,
B_KEY_LEFTCONTROL,
B_KEY_a,
B_KEY_s,
B_KEY_d,
B_KEY_f,
B_KEY_g,
B_KEY_h,
B_KEY_j,
B_KEY_k,
B_KEY_l,
B_KEY_SEMICOLON,
B_KEY_APOSTROPHE,
B_KEY_GRAVE,
B_KEY_LEFTSHIFT,
B_KEY_BACKSLASH,
B_KEY_z,
B_KEY_x,
B_KEY_c,
B_KEY_v,
B_KEY_b,
B_KEY_n,
B_KEY_m,
B_KEY_COMMA,
B_KEY_PERIOD,
B_KEY_SLASH,
B_KEY_RIGHTSHIFT,
B_KEY_KP_MULTIPLY,
B_KEY_ALT,
B_KEY_SPACE,
B_KEY_CAPS_LOCK,
B_KEY_F1,
B_KEY_F2,
B_KEY_F3,
B_KEY_F4,
B_KEY_F5,
B_KEY_F6,
B_KEY_F7,
B_KEY_F8,
B_KEY_F9,
B_KEY_F10,
B_KEY_NUM_LOCK,
B_KEY_SCROLL_LOCK,
B_KEY_KP_7,
B_KEY_KP_8,
B_KEY_KP_9,
B_KEY_KP_SUBTRACT,
B_KEY_KP_4,
B_KEY_KP_5,
B_KEY_KP_6,
B_KEY_KP_ADD,
B_KEY_KP_1,
B_KEY_KP_2,
B_KEY_KP_3,
B_KEY_KP_0,
B_KEY_KP_PERIOD,
B_KEY_LAST_CONSOLE,
B_KEY_LESS,
B_KEY_F11,
B_KEY_F12,
B_KEY_KP_ENTER,
B_KEY_RIGHTCONTROL,
B_KEY_KP_DIVIDE,
B_KEY_VOIDSYMBOL,
B_KEY_ALTGR,
B_KEY_BREAK,
B_KEY_HOME,
B_KEY_UP,
B_KEY_PAGEUP,
B_KEY_LEFT,
B_KEY_RIGHT,
B_KEY_END,
B_KEY_DOWN,
B_KEY_PAGEDOWN,
B_KEY_INSERT,
B_KEY_REMOVE,
B_KEY_PAUSE,

The following keys are using shift key pressed:

B_KEY_EXCLAM,
B_KEY_AT,
B_KEY_NUMBERSIGN,
B_KEY_DOLLAR,
B_KEY_PERCENT,
B_KEY_ASCIICIRCUM,
B_KEY_AMPERSAND,
B_KEY_ASTERISK,
B_KEY_PARENLEFT,
B_KEY_PARENRIGHT,
B_KEY_UNDERSCORE,
B_KEY_PLUS,
B_KEY_Q,
B_KEY_W,
B_KEY_E,
B_KEY_R,
B_KEY_T,
B_KEY_Y,
B_KEY_U,
B_KEY_I,
B_KEY_O,
B_KEY_P,
B_KEY_BRACELEFT,
B_KEY_BRACERIGHT,
B_KEY_A,
B_KEY_S,
B_KEY_D,
B_KEY_F,
B_KEY_G,
B_KEY_H,
B_KEY_J,
B_KEY_K,
B_KEY_L,
B_KEY_COLON,
B_KEY_QUOTEDBL,
B_KEY_ASCIITILDE,
B_KEY_BAR,
B_KEY_Z,
B_KEY_X,
B_KEY_C,
B_KEY_V,
B_KEY_B,
B_KEY_N,
B_KEY_M,
B_KEY_GREATER,
B_KEY_QUESTION,
B_KEY_F13,
B_KEY_F14,
B_KEY_F15,
B_KEY_F16,
B_KEY_F17,
B_KEY_F18,
B_KEY_F19,
B_KEY_F20,
B_KEY_F21,
B_KEY_F22,
B_KEY_SHOW_MEMORY,
B_KEY_F23,
B_KEY_F24,
B_KEY_SCROLL_BACKWARD,
B_KEY_SCROLL_FORWARD,

Now with the alt key, in theory is combined with alt "in theory eye:

B_KEY_CURRENCY,
B_KEY_CENT,
B_KEY_HEX_C,
B_KEY_HEX_A,
B_KEY_SHOW_REGISTERS,
B_KEY_HEX_7,
B_KEY_HEX_8,
B_KEY_HEX_9,
B_KEY_HEX_D,
B_KEY_HEX_4,
B_KEY_HEX_5,
B_KEY_HEX_6,
B_KEY_HEX_E,
B_KEY_HEX_1,
B_KEY_HEX_2,
B_KEY_HEX_3,
B_KEY_HEX_0,
B_KEY_HEX_F,
B_KEY_HEX_B,
B_KEY_USER0,
B_KEY_USER1,
B_KEY_USER2,
B_KEY_USER3,
B_KEY_USER4,
B_KEY_USER5,
B_KEY_USER6,
B_KEY_USER7,
B_KEY_USER8,
B_KEY_USER9,
B_KEY_USER10,
B_KEY_USER11,
B_KEY_USER12,
B_KEY_USER13,
B_KEY_USER14,
B_KEY_NOCODE,
B_KEY_CODES


CALL THE VALUES OF MOUSE

B_MOUSE_RIGHTBUTTON = 0x00000001,
B_MOUSE_MIDDLEBUTTON = 0x00000002,
B_MOUSE_LEFTBUTTON = 0x00000004,
B_MOUSE_FOURTHBUTTON = 0x00000008,
B_MOUSE_FIFTHBUTTON = 0x00000010,
B_MOUSE_SIXTHBUTTON = 0x00000020,
B_MOUSE_RESETBUTTON = 0x00000040,
B_MOUSE_WHEELXBUTTON_U = 0x00000080,
B_MOUSE_WHEELXBUTTON_D = 0x00000100,
B_MOUSE_WHEELYBUTTON_U = 0x00000200,
B_MOUSE_WHEELYBUTTON_D = 0x00000400,
B_MOUSE_USER0BUTTON = 0x00000800,
B_MOUSE_USER1BUTTON = 0x00001000,
B_MOUSE_USER2BUTTON = 0x00002000,
B_MOUSE_USER3BUTTON = 0x00004000,
B_MOUSE_USER4BUTTON = 0x00008000,
B_MOUSE_USER5BUTTON = 0x00010000,
B_MOUSE_USER6BUTTON = 0x00020000,
B_MOUSE_USER7BUTTON = 0x00040000,
B_MOUSE_USER8BUTTON = 0x00080000,
B_MOUSE_USER9BUTTON = 0x00100000,
B_MOUSE_USER10BUTTON = 0x00200000,
B_MOUSE_NONEBUTTON = 0x00400000


VALUES OF CALL OF EVENTS

B_NONE_EVENT = 0x00000000,
B_QUIT_EVENT = 0x00000001,
B_KEYBD_EVENT = 0x00000002,
B_KEYBD_RELEASED = 0x00000004,
B_KEYBD_PRESSED = 0x00000008,
B_MOUSE_EVENT = 0x00000010,
B_MOUSE_OVER = 0x00000020,
B_MOUSE_RELEASED = 0x00000040,
B_MOUSE_PRESSED = 0x00000080,
B_MOUSE_CLICKED = 0x00000100,
B_MOUSE_ENTERED = 0x00000200,
B_MOUSE_EXITED = 0x00000400,
B_MOUSE_HINT = 0x00000800,
B_MOUSE_HINT2 = 0x00001000,
B_EXPOSE_EVENT = 0x00002000,
B_CONFIG_EVENT = 0x00004000,
B_CONFIG_CHNGX = 0x00008000,
B_CONFIG_CHNGY = 0x00010000,
B_CONFIG_CHNGW = 0x00020000,
B_CONFIG_CHNGH = 0x00040000,
B_FOCUS_EVENT = 0x00080000,
B_DESKTOP_EVENT = 0x00100000,
B_TIMER_EVENT = 0x00200000,
B_REMOTE_EVENT = 0x00400000,
B_MOUSE_HANDLER = 0x1,
B_KEYBD_HANDLER = 0x2


STRUCTURE OF CALL BFONTS

This is the next call for the structure of BfontS is its definition and method of linking data at the time of using the function BfontType.

Typedef struct (BFontS
Int yMin;
Int yMax;
Char * str;
Int size;
Int ascent;
Int descent;

Int height;

Int lineskip;
Int underline_offset;
Int underline_height;
Unsigned int RGB;
BImageType * IMG;
BFontFtType * FT;
BFontType);


STRUCTURE OF CALLS AND FUNCTIONS OF MOUSE


The following structure corresponds to the calls made by BmouseS through it is possible to access vectors and functions of state of the mouse on screen.

Typedef struct (BMouseS
Int x;

Int y;

B_MOUSECODE_CODE b;
Int clicks;
B_MOUSECODE_CODE Buttons;
Long Long Time;
Int PX;
Int Py;
Int PB;
B_MOUSECODE_CODE pbuttons;
Long Long ctime;
B_MOUSE_CURSOR cursor;
BMouseType);


FUNCTIONS OF MEMORY


Bmalloc void * (unsigned int size);

Replacement of malloc function, its role is to place the value placed within malloc.

Void * Bcalloc (nmemb unsigned int, unsigned int size);

Function substitute calloc, its variables go by sector memory and associated value.

Void * Brealloc (void * ptr, unsigned int size);

Function substitute realloc, functions as its original role, function call and associated value.

Bfree void (void * ptr);

Function release memory, frees functions used realloc and calloc, it is very useful to save memory and optimize systems.


CHILD FUNCTIONS


BChildAdd int (* BWindowType window, BWindowType * child);

A feature that serves to attach a child.

BChildDel int (* BWindowType window, BWindowType * child);

Function to destroy the chid created previously.

BChildsInit int (* BWindowType window);

Function to launch the child.

BChildsUninit int (* BWindowType window);

Function to download / des-start the child.

FUNCTIONS CLIENT-SERVER

Int BClientInit (BWindowType ** window);

Launch the program as a client system EOS, their use is fairly simple, you simply have to use the variable name with the type of window you use the application.

BClientUninit void (* BWindowType window);

It destroys the function itself, and download the program memory as a client server.

BClientExit void (* BWindowType window);

Close the program and leaves quickly.

BClientQuit void (* BWindowType window);

Function to remove customers, can be used to draw or close to other programs.

BClientWakeup int (* BWindowType window);

A feature that allows re launch an application, it is important to be able to re design the box on the screen and avoid frezadas pages.

BClientChildFind int (* BWindowType parent, BWindowType * window, BEventType * event);

Function for searching child within the client.

Void * BClientLoopEvent (void * arg);

A feature that emulates and simulates an event loop, it is important to provide this feature to C language loop as a continuous loop.

Void * BClientLoop (void * arg);

A feature that allows an infinite loop within a customer.

Void * BClientMain (void * arg);

Principal function to launch an application, lets put a name to the application and variable, as well as taking input values that arg for passing values to an application, which is very useful for programmers.

BClientAtevent void (* BWindowType window, void (* f) (* BWindowType, BEventType *));

A feature that allows an action to determine a specific event, such as a click in the window that can produce the same moves, or a loop in a cycle produces a specific action.

BClientAtexit void (* BWindowType window, void (* f) (BWindowType *));

A feature that determines a value of output for an application, for example call a particular command when a program ends or is terminated.

Struct (BConfigVarS
Char * name;
Char * Value;
);

Struct (BConfigCatS
Char * name;
BListType * variable;
);

Struct (BConfigS
BListType * Category;
);


INI FUNCTIONS FOR READING AND CONFIGURATION OF DATA


Char * BConfigStrip (char * buf);
Int BConfigParse (cfg BConfigType *, char * name);

Define the config file editing and variable regentear.

Int BConfigInit (cfg BConfigType **);

Start reading of the role of config files, this variable must not call BconfigParse.

Int BConfigCategoryInit (BConfigCatType ** cat, char * name);

Select a category to read within the config file.

Int BConfigVariableInit (var BConfigVarType **, char * name, char * value);

Select the value of the category to which work in the config file.

BConfigVariableUninit int (* BConfigVarType var);

Download the value of the variable config.

BConfigCategoryUninit int (* BConfigCatType cat);

Download the value of the variable category in the config.

BConfigUninit int (* BConfigType cfg);

De-function initializes BconfigInit thus is liberated from memory.


TASKS FOR THE PURPOSE OF ANALYSIS OF APPLICATIONS (DEBUG)


Void BDebugDebugf (unsigned short flags, char * file, int line, Govt char *, char * fmt, ...);

A feature that allows placing a flag, and variable that defines an output of a program to monitor its functioning as a debug, if it works as a sprintf but gives a better view of what was happening in the program, and provides for autocreacion a log file in / tmp.


FUNCTIONS OF SURFACE AND VIDEO (HYNTH)


The following functions were provided by the project HYNTH and SDL basically allows about drawing functions native screen.

Bpp_setpixel void (* BSurfaceType surface, int x, int y, int c);
Bpp_setpixel_o void (* BSurfaceType surface, id int, int x, int y, int c);
Bpp_getpixel int (* BSurfaceType surface, int x, int y);
Bpp_getpixel_o int (* BSurfaceType surface, id int, int x, int y);
Bpp_hline void (* BSurfaceType surface, x1 int, int, int x2, int c);
Bpp_hline_o void (* BSurfaceType surface, int id, x1 int, int, int x2, int c);
Bpp_vline void (* BSurfaceType surface, int x, int y1, int y2, int c);
Bpp_vline_o void (* BSurfaceType surface, id int, int x, int y1, int y2, int c);
Bpp_fillbox void (* BSurfaceType surface, int x, int y, int w, h int, int c);
Bpp_fillbox_o void (* BSurfaceType surface, id int, int x, int y, int w, h int, int c);
Bpp_putbox void (* BSurfaceType surface, int x, int y, int w, h int, char * sp, int bw);
Bpp_putbox_mask void (* BSurfaceType surface, int x, int y, int w, h int, char * sp sm unsigned char *, int bw);
Bpp_getbox void (* BSurfaceType surface, int x, int y, int w, h int, char * dp);
Bpp_putbox_o void (* BSurfaceType surface, id int, int x, int y, int w, h int, char * sp, int bw);
Bpp_putbox_mask_o void (* BSurfaceType surface, id int, int x, int y, int w, h int, char * sp sm unsigned char *, int bw);
Bpp_getbox_o void (* BSurfaceType surface, id int, int x, int y, int w, h int, char * dp);


FUNCTIONS OF CALL OF EVENTS


BEventMouseState int (* BWindowType window, BEventType * event, BHandlerMouseType * mouse over int);

Lets call states mouse.

BEventParseMouse void (* BWindowType window, BEventType * event);

Allows editing, observe and track the actions taken by the mouse, it is very helpful if you want to identify the states of the mouse for programs that react according to the actions of the mouse. Ex. If elevates the cursor changes to an image below.

BEventParseKeybd int (* BWindowType window, BEventType * event);

Allows draw events made by the keyboard, for example, if the press had recorded h and produces an action that you want.

BEventParseExpos int (* BWindowType window, BEventType * event);

Interprets values exposed by the events defined and returns to active efflux.

BEventParseConfig int (* BWindowType window, BEventType * event);

Lets start a configuration of the event to begin. The role tabaja through the definition of the type of window and type of event.

BEventParseTimer int (* BWindowType window, BEventType * event);
..
Define the values of action of the events through a temporary remedy, defines the type of window and type of event.

BEventChanged int (* BWindowType window);

Define a change of event within a window and modified.

Int BEventInit (BEventType ** event);

Initializes an event and defines it, this function should be used every time you initialize an event in one application.

BEventUninit int (* BEventType event);

Download the function implemented in the event. You need to define the specific event that initially use.

BEventqInit int (* BWindowType window);

Starts the controller of events.

BEventqUninit int (* BWindowType window);

Download the driver of rapid events.

BEventqAdd int (* BWindowType window, BEventType * event);

It allows a driver annexing fast, it works with the value of the window, and the value of the event.

BEventqGet int (* BWindowType window, BEventType ** event);

Lets get status of a fast event, with the kind of functionality window and type of event.

BEventqWait int (* BWindowType window, BEventType ** event);

Expects an event for fast action.


FUNCTIONS OF SOURCES (FONTS)


Int BFontInit (BFontType ** font, char * name);

Starts functions sources on the screen, this would burden the source to be used, a source with the command name.

BFontUninit int (* BFontType font);

Download the source and the same variable.

BFontSetSize int (* BFontType font, int size);

Sets the size screen showing of the selected font in BfontInit.

Int BFontSetString (BFontType font *, char * str);

He writes on the screen with the selected source, this variable is used as the printf function.

BFontSetRgb int (* BFontType font, int r, g int, int b);

Sets the color display of the source, the default color is always is black. (0,0,0)

BFontGetGlyph int (* BFontType font);

Set up and get values glyph on the screen.


FUNCTIONS OF WRITING ON SCREEN (PIXEL PUT)


Brgbcolor int (* BSurfaceType surface, int r, g int, int b);
Bcolorrgb void (* BSurfaceType surface, int c, r * int, int * g * int b);
Bsetpixel void (* BSurfaceType surface, int x, int y, int c);
Bsetpixelrgb void (* BSurfaceType surface, int x, int y, int r, g int, int b);
Bsetpixelrgba void (* BSurfaceType surface, int x, int y, int r, g int, int b, to int);
Bgetpixel int (* BSurfaceType surface, int x, int y);
Bgetpixelrgb void (* BSurfaceType surface, int x, int y, int * r, g * int, int * b);
Bhline void (* BSurfaceType surface, x1 int, int, int x2, int c);
Bvline void (* BSurfaceType surface, int x, int y1, int y2, int c);
Bline void (* BSurfaceType surface, x1 int, int y1, int x2, y2 int, int c);
Bfillbox void (* BSurfaceType surface, int x, int y, int w, h int, int c);
Bputbox void (* BSurfaceType surface, int x, int y, int w, h int, char * sp);
Bputboxmask void (* BSurfaceType surface, int x, int y, int w, h int, char * sp, unsigned char * sm);
Bputboxalpha void (* BSurfaceType surface, int x, int y, int w, h int, char * sp, unsigned char * sm);
Bputboxrgba void (* BSurfaceType surface, int x, int y, int w, h int, unsigned int * rgba);
Bgetbox void (* BSurfaceType surface, int x, int y, int w, h int, char * dp);
Bputboxpart void (* BSurfaceType surface, int x, int y, int w, h int, int bw, bh int, char * sp xo int, int I);
Bputboxpartmask void (* BSurfaceType surface, int x, int y, int w, h int, int bw, bh int, char * sp sm unsigned char *, int xo, I int);
Bputboxpartrgba void (* BSurfaceType surface, int x, int y, int w, h int, int bw, bh int, unsigned int * rgba, xo int, int I);
Bputboxpartalpha void (* BSurfaceType surface, int x, int y, int w, h int, int bw, bh int, char * sp sm unsigned char *, int xo, I int);
Bcopybox void (* BSurfaceType surface, x1 int, int y1, int w, int h, x2 int, int y2);
Void Bgetsurfacevirtual (BSurfaceType * s, int w, int h bitspp int, char * vbuf);
Int Bcopybuffer (sb char *, int sbitspp, char ** db, dbitspp int, int w, int h);
Brotatebox void (* BSurfaceType surface, BRectType * srect, void * sbuf, BRectType * drect, dbuf void *, int rotate);
Bscalebox void (* BSurfaceType surface, int w1, int h1, void * _dp1, w2 int, int h2, _dp2 void *);


FUNCTIONS OF CALLS AND MOUSE TELCADO (HANDLERS)


Then we define the functions of call, depending on their structure and data so you can understand how this shaped the structure of each function.

STRUCTURE OF CALLS FOR KEYS

Struct (BHandlerKeybdS

Int flag;

Int Button;
Void (* p) (BWindowType * * BEventType, BHandlerType *);
Void (* r) (BWindowType * * BEventType, BHandlerType *);
);


STRUCTURE OF THE MOUSE LLAMDAS

Struct (BHandlerMouseS
Int x;
Int y;
Int w;
Int h;
Int Button;
Void (* p) (BWindowType * * BEventType, BHandlerType *);
Void (* r) (BWindowType * * BEventType, BHandlerType *);
Void (* c) (BWindowType * * BEventType, BHandlerType *);

Void (*) (or BWindowType * * BEventType, BHandlerType *);

Void (*) (ho BWindowType * * BEventType, BHandlerType *);
Void (*) (hr * BWindowType, BEventType * BHandlerType *);
Void (*) (oh BWindowType * * BEventType, BHandlerType *);
Void (*) (hoh BWindowType * * BEventType, BHandlerType *);
Void (*) (rh BWindowType * * BEventType, BHandlerType *);
B_EVENT hstate;
);

STRUCTURE OF HANDLERS (CALLS)

Struct (BHandlerS

B_HANDLER type;

BHandlerMouseType Mouse;
BHandlerKeybdType keybd;
Void * user_data;
);

Struct (BHandlersS
BListType * List;
* BThreadMutexType Mut;
);


Int BHandlerInit (BHandlerType ** handler);

It initializes the role of callers and defines the value of the handler, this is important in linking widgets and functions through actions and reactions in the code, do not forget to initialize otherwise your code will have no functionality.

Int BHandlerUninit (BHandlerType * handler);

De-initializes the callback function, downloading the handler previously created, it allows you to reset, change or delete statements.

BHandlerAdd int (* BWindowType window, BHandlerType * handler);

Annexed call (handler) within a window and the value specified handler.

BHandlerDel int (* BWindowType window, BHandlerType * handler);

Eliminates a call handler that has been previously initialized.

BHandlersInit int (* BWindowType window);

Starts function simultaneous calls.

BHandlersUninit int (* BWindowType window);

Download the role of simultaneous calls.


FUNCTIONS OF USE AND BURDEN OF IMAGES


Then defeniremos fields that are used to load and place an image in bitmap formats, xpm, and gif (compressed without frames).

This is the structure of code used for the reading of images:

Struct (BImageS
Int x;
Int y;
Int w;
Int h;
Char * buf;

Unsigned char * MAT;

* BRectType Handler;
Unsigned int DeLay;
Unsigned int * rgba;
* BListType layers;
);

Int BImageHex2int (char * str);

Spend the value of the image to an interruption to be read into memory.

BImageGetMat int (* BImageType img);

Gets the image data.

BImageGetBuf int (* BSurfaceType surface, BImageType img *);

Put and image data obtained in the output buffer.

BImageGetHandler void (* BImageType img);

Take the image within the handler, it is useful to make links with code widgets.

Int BImageInit (img BImageType **);

It initializes the role of image loading, it is necessary to define that image will be charged and under what variable.

BImageFreeBuf void (* BImageType img);

Libera buffer used previously by the image loaded.

BImageFreeMat void (* BImageType img);

Libera data from the materials obtained in advance by the image (similar to get_pixel).

BImageFreeRgba void (* BImageType img);

Libera RGB data (actual colors) and the color palette of the image loaded.

BImageFreeHandler void (* BImageType img);

Libera value associated with the handler for the desired image.

BImageUninit int (* BImageType img);

Download the role of image loading.

Int BImageLayerInit (BImageType lyr **);

Initializes layer reading of images.

BImageLayerUninit int (* BImageType lyr);

Download layer reading of images.

BImageLayersInit int (* BImageType img);

It initializes the burden of multiple images.

BImageLayersUninit int (* BImageType img);

Descara loads images.

Int BImageImg (char * file, BImageType img *);

Function and cargo handler association of images, is the main function if searching upload an image and display it.

Functions read GIF files

Int BImageGifIs (char * file);

Defines whether the file is in gif or not, it returns a value of 1 if the format and 0 in the case that is not the type of file.

Int BImageGif (char * file, BImageType img *);

Loads a GIF image in memory.

Functions reading files PNG

Int BImagePngIs (char * file);

Defines whether the file is in PNG format or not, it returns a value of 1 if the format and 0 in the case that is not the type of file.

Int BImagePng (char * file, BImageType img *);

PNG load an image into memory.

Functions reading files XPM

Int BImageXpmIs (char * file);

Defines whether the file is XPM format or not, it returns a value of 1 if the format and 0 in the case that is not the type of file.

Int BImageXpm (char * file, BImageType img *);

Load an image XPM memory.


FUNCTIONS OF LISTING FOR USEFUL LINK FUNCTIONS


The functions performed sisguientes functions to link variables are very important if you look lists returned by state programs, or just looking to read the contents of a file or variables.

The data structure of BLIST is as follows:

Struct (BListNodeS
         Void * next;
         Void * Element;
);

Struct (BListS
         Int nb_elt;
         BListNodeType * Node;
);

Int BListInit (BListType ** l);

Initializes function, should set the value of BLIST.

BListUninit int (* BListType li);

Descara the value that gave BLIST.

BListEol int (* BListType Li, int i);

Initializes EOL counting on the list, you must define the BLIST and shall list the values to work.

Void * BListGet (BListType l *, int pos);

Gets BLIST values within a particular position, its role is to define the BLIST and place the point position.

BListRemove int (* BListType Li, int pos);

Remove BLIST the beginning and its position listed.

BListAdd int (* BListType Li, void *, int pos);

Add a new list within a value and position.

BListFind void * (* BListType list, node void *, int (* cmp_func) (void *, void *));

Look for a list within a BLIST, in a position and function.

BListGetPos int (* BListType list, void * node);

Gets the position of a given LIST.


FUNCTIONS OF OBJECT


The following features allow you to have control over the objects that will be presented within a program in a BOX.

BObjectUpdateToSurface int (* BObjectType object, BSurfaceType * surface, co BRectType *);

Declares that the object can be updated within a given area, this feature is useful when working with sprites.

BObjectUpdate int (* BObjectType object, co BRectType *);

Updates the position and status of the object.

BObjectMove int (* BObjectType object, int x, int y, int w, int h);

Moves the object in a given coordinate space inside the BOX, can never move outside the BOX.

BObjectHide int (* BObjectType object);

Allows hide the object, therefore behave so invisible.

BObjectShow int (* BObjectType object);

Allows viewing the object, is the only way to make it visible, if not declaring may never see their objects on the screen.

BObjectInit int (* BWindowType window, BObjectType ** object, int w, int h * BObjectType parent);

Starts the role of subject, object that defines the use, it can be a function of native drawing, or a section of the screen, and defines the initial position where they submit, as well as the size you will have inside the BOX.

BObjectUninit int (* BObjectType object);

Download the subject of memory.


FUNCTIONS POLL


The following features allow you to control the functions POLLS within their application.

Int BPollfdInit (BPollfdType ** pfd);

Cargo and defines POLL in memory.

BPollfdUninit int (* BPollfdType pfd);

Download POLL from memory.

BPollfdType * BPollfdFind (BWindowType window *, int fd);

Defines the type POLL employed within the BOX.

BPollfdAdd int (* BWindowType window, BPollfdType pfd *);

Annexed a new POLL.

BPollfdDel int (* BWindowType window, BPollfdType pfd *);

POLL Remove an existing but not erased from memory.

BPollfdsInit int (* BWindowType window);

It initializes the role of multiple POLLS.

BPollfdsUninit int (* BWindowType window);

Download the role of multiple POLLS.

Structure definition of a BPOLL:

Struct (BPollfdS
Int fd;
Int (* pf_in) (BWindowType *, int);
Int (* pf_err) (BWindowType *, int);
Int (* pf_close) (BWindowType *, int);
);

Struct (BPollfdsS
BListType * List;
* BThreadMutexType Mut;
);


FUNCTIONS OF DRAWING RECT


Then defeniremos the operating structure of BRECT:

Struct (BRectS
Int x;
Int y;
Int w;
Int h;
);


Int BRectIntersect (BRectType * r1, BRectType * r2, BRectType * r);

Functions drawing rectangles with intersections.

BRectClipVirtual int (* BSurfaceType surface, int x, int y, int w, int h, co BRectType *);

Function drawing clip virtual space must define values and height and width.

BRectClipReal int (* BSurfaceType surface, int x, int y, int w, int h, co BRectType *);

Function definition of rectangle with actual clip, you must define the real values x, yy width and height values.

BRectDifferenceAdd int (* BListType list, int x, int y, int w, int h);

A feature that lets you attach a new definition to differentiating between 2 rectangles.

Int BRectDifference (BRectType * r1, BRectType * r0, BListType * list);

Define a rectangle differential.


FUNCTIONS SOCKET (NETS)


BSocketRequestNew int (* BWindowType window, soc int);
BSocketRequestDisplay int (* BWindowType window, soc int);
BSocketRequestConfigure int (* BWindowType window, int soc, B_WINDOW form);
BSocketRequestStream int (* BWindowType window, int soc, co BRectType *);
BSocketRequestShow int (* BWindowType window, soc int, int id, int show);
BSocketRequestEvent int (* BWindowType window, int soc, BEventType * event);
BSocketRequest int (* BWindowType window, B_SOC_DATA req, ...);
BSocketListenEvent int (* BWindowType window, soc int);
BSocketListenExpose int (* BWindowType window, soc int);
BSocketListenDesktop int (* BWindowType window, soc int);
BSocketListenParse int (* BWindowType window, soc int);
BSocketListenWait int (* BWindowType window, int timeout);
BSocketUninit int (* BWindowType window, int s);
BSocketInF int (* BWindowType window, int s);
BSocketIerrF int (* BWindowType window, int s);
BSocketInwF int (* BWindowType window, int s);
BSocketIerrwF int (* BWindowType window, int s);
BSocketClosewF int (* BWindowType window, int s);
BSocketInitUds int (* BWindowType window);
BSocketInitTcp int (* BWindowType window);
BSocketInitWakeup int (* BWindowType window);
BSocketInit int (* BWindowType window);


BASIC FUNCTIONS OF SURFACE ON SCREEN


Listing SURFACE native functions based on the SDL library.

BSurfaceInit int (* BWindowType window);

It starts a surface, you must define the type of BOX.

BSurfaceCreate void (* BWindowType window);

It creates a surface, it must be defined before BSURFACEINIT it will not take effect this function.

BSurfaceShmAttach void (* BWindowType window);

Annexed a new surface to existing within a BOX.

BSurfaceLinear void (* BWindowType window);

It generates a linear surface, giving an effect of SCROLL.

BSurfaceUninit void (* BWindowType window);

A feature that removes memory function BSURFACE, rendering null and void all actions on the surface.

BSurfaceChanged void (* BWindowType window, changed BRectType *);

Allows states and modify properties of BSURFACE online.


FUNCTIONS OF MANAGEMENT OF THE FUNCTIONS THREAD IN UCLIBC


Then define the functions that are used by THREAD UCLIBC in EOS, in this way can create processes THREAD direct and employ them in their own BOXS.

Int BThreadSemCreate (** BThreadSemType week, initial int);
BThreadSemDestroy int (* BThreadSemType wk);
BThreadSemWait int (* BThreadSemType wk);
BThreadSemWaitTimeout int (* BThreadSemType week, int msec);
BThreadSemPost int (* BThreadSemType wk);
Int BThreadMutexInit (mut BThreadMutexType **);
BThreadMutexDestroy int (* BThreadMutexType mut);
BThreadMutexLock int (* BThreadMutexType mut);
BThreadMutexTrylock int (* BThreadMutexType mut);
BThreadMutexUnlock int (* BThreadMutexType mut);
Int BThreadCondInit (BThreadCondType ** cond);
BThreadCondDestroy int (* BThreadCondType cond);
BThreadCondSignal int (* BThreadCondType cond);
BThreadCondBroadcast int (* BThreadCondType cond);
BThreadCondWait int (* BThreadCondType cond, BThreadMutexType Mut *);
BThreadCondTimedwait int (* BThreadCondType cond, BThreadMutexType Mut *, int msec);
BThreadType * BThreadCreate (void * (* f) (void *), void * farg);
BThreadCancel int (* BThreadType time);
BThreadJoin int (* BThreadType time, void ** ret);
Int BThreadSelf (void);
BThreadExit void (void * ret);


FUNCTIONS OF CONTROL OF TIME


Then defeniremos values structure possessing the functions BTIMER.

Struct (BTimerS
Long Long timeval;
Long Long interval;
Void (*) (cb BWindowType *, struct BTimerS *);
Void * user_data;
);

Struct (BTimersS
* BListType timers;

* BThreadMutexType Mut;

);


Int BTimerInit (BTimerType ** timer);

Start counting function of time.

BTimerTypeimeval int (* BWindowType window, BTimerType * timer, timeval int);

It details the type of time interval to be used.

BTimerUninit int (* BTimerType timer);

Download the role of counting time.

BTimerDel int (* BWindowType window, BTimerType * timer);

It eliminates the variable of time to be using this.

BTimerAdd int (* BWindowType window, BTimerType * timer);

Add a new condenser and controller of time, its functionality is the type of BOX and the kind of time to be used for administration of the same in the application.

BTimersInit int (* BWindowType window);

Starts the multiple role of meter times.

BTimersUninit int (* BWindowType window);

Download the multiple role of meter times.


FUNCTIONS AND CONFIGURATION CONTROL OF WINDOW BOX


Then define the major routines for loading boxes box on your desktop, these functions let you control what happens in one area of the screen, and from them to begin to develop an application.

BWindowSetCursor void (* BWindowType window, B_MOUSE_CURSOR cursor);

Puts and shapes the kind of cursor to the box.

BWindowSetTitle void (* BWindowType window, char * fmt, ...);

Sets the title to take the box.

BWindowFormDraw void (* BWindowType window);

Set the type of BOX to use (format).

BWindowHide void (* BWindowType window);

Set BOX invisibly, or is not visible to its processes, however it is possible to access it through the taskbar.

BWindowShow void (* BWindowType window);

Principal function that shows the program itself, in this case shows BOX screen without this variable is not showing its programs.

BWindowSetCoor void (* BWindowType window, the form int, int x, int y, int w, int h);

Set position on the screen of BOX.

BWindowSetResizeable void (* BWindowType window, resizeable int);

Sets whether it is possible to modify the size and space of BOX, the values are 0 and 1, where 0 was identified that BOX will not be resizable and if the value is 1 will be possible to alter its size.

BWindowSetAlwaysontop void (* BWindowType window, alwaysontop int);

Displays BOX continuously on the screen, it is helpful if you look BOX make a primary task, which is continually shown and that other programs can not superponerseles, it is useful if you are looking to make a SHELL alternative to the system.


BWindowNew int (* BWindowType window, B_WINDOW type, BWindowType * parent);

It generates a new BOX screen, you must define a variable BOX, the type of BOX (B_WINDOW) and the kind of courage that will have the BOX.



Features graphics native (SDL)


The functions SDL is a graphics layer that owns EOS are based on the original SDL libraries, with the proviso that have been OPTIMIZADAS to the point of allowing access to hardware acceleration, although there are some limitations such as the inability to change the icon Cursor, or modify tasks in the system, to perform some of these changes we recommend that you read about the primitive functions that previously we have set out.


OpenGL in EOS


Currently we have a small port of TINYGL in SDL, the same permit recompile few codes made OPENGL but bring many disadvantages, allow development in 3d and obtain high yields, but are placed on the primary task, which generates some of relentizaciones system.
We recommend using this PORT carefully, and to read more information about the port in the section of the SDK / SRC / LIBS / LIBGL.


GTK for EOS


At the moment is in development, however it is possible to run GTK Under the Xserver for EOS, therefore you can see all your old programs in a BOX. However, this has serious limitations because it runs in a BOX rather than a table DIALOGUE.


QT for EOS


We have no PORT echo except that operates under Xserver in EOS.