gok-chunker

gok-chunker

Synopsis

enum                ChunkTypes;
enum                ChunkOrder;
gboolean            gok_chunker_chunk_all               (ChunkTypes TypeChunks,
                                                         ChunkOrder chunkOrder);
void                gok_chunker_init_chunk              (GokChunk *pChunk);
void                gok_chunker_delete_chunks           (GokChunk *pChunk,
                                                         gboolean bAlsoNext);
void                gok_chunker_reset                   (void);
void                gok_chunker_next_chunk              (void);
void                gok_chunker_previous_chunk          (void);
void                gok_chunker_next_key                (void);
void                gok_chunker_previous_key            (void);
void                gok_chunker_keyup                   (void);
void                gok_chunker_keydown                 (void);
void                gok_chunker_keyleft                 (void);
void                gok_chunker_keyright                (void);
void                gok_chunker_keyhighlight            (void);
gboolean            gok_chunker_wraptofirstchunk        (void);
gboolean            gok_chunker_wraptolastchunk         (void);
gboolean            gok_chunker_wraptofirstkey          (void);
gboolean            gok_chunker_wraptolastkey           (void);
gboolean            gok_chunker_wraptoleft              (gint TrueFalse);
gboolean            gok_chunker_wraptoright             (gint TrueFalse);
void                gok_chunker_move_leftright          (gint TrueFalse);
void                gok_chunker_move_topbottom          (gint TrueFalse);
gint                gok_chunker_if_next_chunk           (void);
gint                gok_chunker_if_previous_chunk       (void);
gint                gok_chunker_if_next_key             (void);
gint                gok_chunker_if_previous_key         (void);
gint                gok_chunker_if_top                  (void);
gint                gok_chunker_if_bottom               (void);
gint                gok_chunker_if_left                 (void);
gint                gok_chunker_if_right                (void);
gint                gok_chunker_if_key_selected         (void);
gboolean            gok_chunker_is_left                 (GokKey *pKey1,
                                                         GokKey *pKey2);
gboolean            gok_chunker_is_right                (GokKey *pKey1,
                                                         GokKey *pKey2);
gboolean            gok_chunker_is_top                  (GokKey *pKey1,
                                                         GokKey *pKey2);
gboolean            gok_chunker_is_bottom               (GokKey *pKey1,
                                                         GokKey *pKey2);
void                gok_chunker_counter_set             (gint CounterId,
                                                         gint CounterValue);
void                gok_chunker_counter_increment       (gint CounterId);
void                gok_chunker_counter_decrement       (gint CounterId);
void                gok_chunker_state_restart           (void);
void                gok_chunker_state_next              (void);
void                gok_chunker_state_jump              (gchar *NameState);
gboolean            gok_chunker_select_chunk            (void);
void                gok_chunker_highlight_chunk         (GokChunk *pChunk);
void                gok_chunker_unhighlight_chunk       (GokChunk *pChunk);
void                gok_chunker_highlight_center_key    (void);
void                gok_chunker_highlight_first_chunk   (void);
void                gok_chunker_highlight_first_key     (void);
gboolean            gok_chunker_insert_item_row_ltr     (GokChunk *pChunk,
                                                         GokChunkitem *pChunkitem);
gboolean            gok_chunker_insert_item_row_rtl     (GokChunk *pChunk,
                                                         GokChunkitem *pChunkitem);
gboolean            gok_chunker_insert_item_col_ttb     (GokChunk *pChunk,
                                                         GokChunkitem *pChunkitem);
gboolean            gok_chunker_insert_item_col_btt     (GokChunk *pChunk,
                                                         GokChunkitem *pChunkitem);
void                gok_chunker_dump_chunks             (void);
void                gok_chunker_dump_chunk              (GokChunk *pChunk);
GokChunk *          gok_chunker_chunk_group             (GokChunk *pChunk,
                                                         gint NumberGroups,
                                                         ChunkOrder Order,
                                                         gboolean bCanReorder);
void                gok_chunker_add_chunkitem           (GokChunk *pChunk,
                                                         GokChunkitem *pChunkitem);
gint                gok_chunker_count_chunkitems        (GokChunk *pChunk);
GokChunk *          gok_chunker_make_2_vertical         (GokChunk *pChunk);
GokChunk *          gok_chunker_make_2_horizontal       (GokChunk *pChunk);
GokChunk *          gok_chunker_make_4                  (GokChunk *pChunk);
void                gok_chunker_highlight_chunk_number  (gint Number);
GokChunk *          gok_chunker_get_chunk               (gint Number);
void                gok_chunker_highlight_all_keys      (void);
void                gok_chunker_unhighlight_all_keys    (void);
void                gok_chunker_resolve_overlap         (GokChunk *pChunk);

Description

Details

enum ChunkTypes

typedef enum {
CHUNKER_RESET,
CHUNKER_NOCHUNKS,
CHUNKER_KEYS,
CHUNKER_ROWS,
CHUNKER_COLUMNS,
CHUNKER_RECURSIVE,
CHUNKER_2GROUPS,
CHUNKER_3GROUPS,
CHUNKER_4GROUPS,
CHUNKER_5GROUPS,
CHUNKER_6GROUPS
} ChunkTypes;


enum ChunkOrder

typedef enum {
CHUNKER_TOPTOBOTTOM_LEFTTORIGHT,
CHUNKER_TOPTOBOTTOM_RIGHTTOLEFT,
CHUNKER_BOTTOMTOTOP_LEFTTORIGHT,
CHUNKER_BOTTOMTOTOP_RIGHTTOLEFT,
CHUNKER_LEFTTORIGHT_TOPTOBOTTOM,
CHUNKER_LEFTTORIGHT_BOTTOMTOTOP,
CHUNKER_RIGHTTOLEFT_TOPTOBOTTOM,
CHUNKER_RIGHTTOLEFT_BOTTOMTOTOP
} ChunkOrder;


gok_chunker_chunk_all ()

gboolean            gok_chunker_chunk_all               (ChunkTypes TypeChunks,
                                                         ChunkOrder chunkOrder);

Breaks all the keyboards into chunks.

TypeChunks :

The type of chunks required e.g. rows or columns. (See the enum 'ChunkTypes' for possible values.)

chunkOrder :

Returns :

TRUE if everything went OK, FALSE if there was any problem.

gok_chunker_init_chunk ()

void                gok_chunker_init_chunk              (GokChunk *pChunk);

Initializes a GOK chunk. This must be called after creating any chunk.

pChunk :

Pointer to the chunk that will be initialized.

gok_chunker_delete_chunks ()

void                gok_chunker_delete_chunks           (GokChunk *pChunk,
                                                         gboolean bAlsoNext);

Deletes a chunk and, optionally, any following chunks.

pChunk :

Pointer to the first chunk in the list of chunks that gets deleted.

bAlsoNext :

If TRUE then all chunks following the one given will be deleted.

gok_chunker_reset ()

void                gok_chunker_reset                   (void);

gok_chunker_next_chunk ()

void                gok_chunker_next_chunk              (void);

Highlightes the next chunk.


gok_chunker_previous_chunk ()

void                gok_chunker_previous_chunk          (void);

Highlightes the previous chunk.


gok_chunker_next_key ()

void                gok_chunker_next_key                (void);

Highlightes the next key in the chunk.


gok_chunker_previous_key ()

void                gok_chunker_previous_key            (void);

Highlightes the previous key in the selected chunk.


gok_chunker_keyup ()

void                gok_chunker_keyup                   (void);

Highlights and selects the key to the top of the currently highlighted key. This does NOT wrap to the bottom side of the keyboard (call gok_chunker_wraptobottom).


gok_chunker_keydown ()

void                gok_chunker_keydown                 (void);

Highlights and selects the right to the bottom of the currently highlighted key. This does NOT wrap to the top side of the keyboard (call gok_chunker_wraptotop).


gok_chunker_keyleft ()

void                gok_chunker_keyleft                 (void);

Highlights and selects the key to the left of the currently highlighted key. This does NOT wrap to the right side of the keyboard (call gok_chunker_wraptoright).


gok_chunker_keyright ()

void                gok_chunker_keyright                (void);

Highlights and selects the right to the right of the currently highlighted key. This does NOT wrap to the left side of the keyboard (call gok_chunker_wraptoleft).


gok_chunker_keyhighlight ()

void                gok_chunker_keyhighlight            (void);

Highlights the given key.

NOT USED (deprecate?)


gok_chunker_wraptofirstchunk ()

gboolean            gok_chunker_wraptofirstchunk        (void);

Highlights the first chunk in the list of chunks

Returns :

TRUE if successful, FALSE if not.

gok_chunker_wraptolastchunk ()

gboolean            gok_chunker_wraptolastchunk         (void);

Highlights the last chunk in the list of chunks

Returns :

TRUE if successful, FALSE if not.

gok_chunker_wraptofirstkey ()

gboolean            gok_chunker_wraptofirstkey          (void);

Highlights the first key in the list of keys.

Returns :

TRUE if successful, FALSE if not.

gok_chunker_wraptolastkey ()

gboolean            gok_chunker_wraptolastkey           (void);

Highlights the last key in the list of keys.

Returns :

TRUE if successful, FALSE if not.

gok_chunker_wraptoleft ()

gboolean            gok_chunker_wraptoleft              (gint TrueFalse);

Highlights the leftmost key that is on the same row as the currently selected key.

TrueFalse :

unused.

Returns :

TRUE if successful, FALSE if not.

gok_chunker_wraptoright ()

gboolean            gok_chunker_wraptoright             (gint TrueFalse);

Highlights the rightmost key that is on the same row as the currently selected key.

TrueFalse :

unused

Returns :

TRUE if successful, FALSE if not.

gok_chunker_move_leftright ()

void                gok_chunker_move_leftright          (gint TrueFalse);

Not implemented yet.

TrueFalse :

unused

gok_chunker_move_topbottom ()

void                gok_chunker_move_topbottom          (gint TrueFalse);

Not implemented yet.

TrueFalse :

unused

gok_chunker_if_next_chunk ()

gint                gok_chunker_if_next_chunk           (void);

Tests if there is another chunk after the current chunk.

Returns :

TRUE if there is a next chunk, FALSE if not.

gok_chunker_if_previous_chunk ()

gint                gok_chunker_if_previous_chunk       (void);

Tests if there is another chunk before the current chunk.

Returns :

TRUE if there is a previous chunk, FALSE if not.

gok_chunker_if_next_key ()

gint                gok_chunker_if_next_key             (void);

Tests if there is another key after the current key.

Returns :

TRUE if there is a next key, FALSE if not.

gok_chunker_if_previous_key ()

gint                gok_chunker_if_previous_key         (void);

Tests if there is another key before the current key.

Returns :

TRUE if there is a key chunk, FALSE if not.

gok_chunker_if_top ()

gint                gok_chunker_if_top                  (void);

Tests if there is a key to the top of the currently highlighted key.

Returns :

TRUE if there is a key to the top, FALSE if not.

gok_chunker_if_bottom ()

gint                gok_chunker_if_bottom               (void);

Tests if there is a key to the bottom of the currently highlighted key.

Returns :

TRUE if there is a key to the bottom, FALSE if not.

gok_chunker_if_left ()

gint                gok_chunker_if_left                 (void);

Tests if there is a key to the left of the currently highlighted key.

Returns :

TRUE if there is a key to the left, FALSE if not.

gok_chunker_if_right ()

gint                gok_chunker_if_right                (void);

Tests if there is a key to the right of the currently highlighted key.

Returns :

TRUE if there is a key to the right, FALSE if not.

gok_chunker_if_key_selected ()

gint                gok_chunker_if_key_selected         (void);

Returns :

Alwasy 0.

gok_chunker_is_left ()

gboolean            gok_chunker_is_left                 (GokKey *pKey1,
                                                         GokKey *pKey2);

Tests if a key is left of another key. This does NOT test if the keys are on the same row. This should be called when traversing a row from right to left.

pKey1 :

Key you want to test.

pKey2 :

Key you want to compare against.

Returns :

TRUE if pKey1 is left of pKey2, FALSE if pKey2 is left of pKey1.

gok_chunker_is_right ()

gboolean            gok_chunker_is_right                (GokKey *pKey1,
                                                         GokKey *pKey2);

Tests if a key is right of another key. This does NOT test if the keys are on the same row. This should be called when traversing a row from left to right.

pKey1 :

Key you want to test.

pKey2 :

Key you want to compare against.

Returns :

TRUE if pKey1 is right of pKey2, FALSE if pKey2 is left of pKey1.

gok_chunker_is_top ()

gboolean            gok_chunker_is_top                  (GokKey *pKey1,
                                                         GokKey *pKey2);

Tests if a key is top of another key. This does NOT test if the keys are on the same column. This should be called when traversing a column from bottom to top.

pKey1 :

Key you want to test.

pKey2 :

Key you want to compare against.

Returns :

TRUE if pKey1 is higher than pKey2, FALSE if pKey2 is higher than pKey1.

gok_chunker_is_bottom ()

gboolean            gok_chunker_is_bottom               (GokKey *pKey1,
                                                         GokKey *pKey2);

Tests if a key is bottom of another key. This does NOT test if the keys are on the same column. This should be called when traversing a column from top to bottom.

pKey1 :

Key you want to test.

pKey2 :

Key you want to compare against.

Returns :

TRUE if pKey1 is bottom of pKey2, FALSE if pKey2 is bottom of pKey1.

gok_chunker_counter_set ()

void                gok_chunker_counter_set             (gint CounterId,
                                                         gint CounterValue);

CounterId :

Counter you want to set.

CounterValue :

Value you want the counter set to.

gok_chunker_counter_increment ()

void                gok_chunker_counter_increment       (gint CounterId);

CounterId :

Counter you want to increment.

gok_chunker_counter_decrement ()

void                gok_chunker_counter_decrement       (gint CounterId);

CounterId :

Counter you want to decrement.

gok_chunker_state_restart ()

void                gok_chunker_state_restart           (void);

Move to the first state.


gok_chunker_state_next ()

void                gok_chunker_state_next              (void);

Move to the next state. Move to the first state if at the last state.


gok_chunker_state_jump ()

void                gok_chunker_state_jump              (gchar *NameState);

Change state to the given state.

NameState :

Name of the state you want to jump to.

gok_chunker_select_chunk ()

gboolean            gok_chunker_select_chunk            (void);

Sets the current chunk as the selected chunk.

Returns :

The number of keys in the selected chunk.

gok_chunker_highlight_chunk ()

void                gok_chunker_highlight_chunk         (GokChunk *pChunk);

Highlightes the given chunk. Updates m_pChunkHighlighted with the chunk given.

pChunk :

Pointer to the chunk that will be highlighted.

gok_chunker_unhighlight_chunk ()

void                gok_chunker_unhighlight_chunk       (GokChunk *pChunk);

Unhighlightes the given chunk. Updates m_pChunkHighlighted.

pChunk :

Pointer to the chunk that will be unhighlighed (made normal).

gok_chunker_highlight_center_key ()

void                gok_chunker_highlight_center_key    (void);

Highlightes the center key on the current keyboard.


gok_chunker_highlight_first_chunk ()

void                gok_chunker_highlight_first_chunk   (void);

Highlightes the first chunk on the current keyboard. Updates m_pChunkHighlighted.


gok_chunker_highlight_first_key ()

void                gok_chunker_highlight_first_key     (void);

Highlightes the first key in the selected chunk. Updates m_pChunkitemHighlighted.


gok_chunker_insert_item_row_ltr ()

gboolean            gok_chunker_insert_item_row_ltr     (GokChunk *pChunk,
                                                         GokChunkitem *pChunkitem);

Adds a chunkitem (key) to a chunk (row). The new chunkitem will be added in the sequence left to right (the leftmost key is the first key in the sequence).

pChunk :

Pointer to the first chunk that will contain the new chunkitem.

pChunkitem :

Pointer to the chunkitem that gets added to the chunk.

Returns :

TRUE if the chunkitem was added to the chunk, FALSE if not.

gok_chunker_insert_item_row_rtl ()

gboolean            gok_chunker_insert_item_row_rtl     (GokChunk *pChunk,
                                                         GokChunkitem *pChunkitem);

Adds a chunkitem (key) to a chunk (row). The new chunkitem will be added in the sequence right to left (the rightmost key is the first key in the sequence).

pChunk :

Pointer to the first chunk that will contain the new chunkitem.

pChunkitem :

Pointer to the chunkitem that gets added to the chunk.

Returns :

TRUE if the chunkitem was added to the chunk, FALSE if not.

gok_chunker_insert_item_col_ttb ()

gboolean            gok_chunker_insert_item_col_ttb     (GokChunk *pChunk,
                                                         GokChunkitem *pChunkitem);

Adds a chunkitem (key) to a chunk (column). The new chunkitem will be added in the sequence top to bottom (the topmost key is the first key in the sequence).

pChunk :

Pointer to the first chunk that will contain the new chunkitem.

pChunkitem :

Pointer to the chunkitem that gets added to the chunk.

Returns :

TRUE if the chunkitem was added to the chunk, FALSE if not.

gok_chunker_insert_item_col_btt ()

gboolean            gok_chunker_insert_item_col_btt     (GokChunk *pChunk,
                                                         GokChunkitem *pChunkitem);

Adds a chunkitem (key) to a chunk (column). The new chunkitem will be added in the sequence bottom to top (the bottommost key is the first key in the sequence).

pChunk :

Pointer to the first chunk that will contain the new chunkitem.

pChunkitem :

Pointer to the chunkitem that gets added to the chunk.

Returns :

TRUE if the chunkitem was added to the chunk, FALSE if not.

gok_chunker_dump_chunks ()

void                gok_chunker_dump_chunks             (void);

Diagnostic function that prints all the chunks to stdout.


gok_chunker_dump_chunk ()

void                gok_chunker_dump_chunk              (GokChunk *pChunk);

Diagnostic function that prints the chunk to stdout.

pChunk :

Pointer to the chunk that gets the dump.

gok_chunker_chunk_group ()

GokChunk *          gok_chunker_chunk_group             (GokChunk *pChunk,
                                                         gint NumberGroups,
                                                         ChunkOrder Order,
                                                         gboolean bCanReorder);

Breaks the given list of chunks into 2 or more groups.

pChunk :

Pointer to the list of chunks that will be broken into groups.

NumberGroups :

Number of groups the chunks should be broken into.

Order :

The order in which the chunks should be created. (see enum ChunkOrder)

bCanReorder :

TRUE if the chunks can be reordered.

Returns :

A pointer to the first chunk in the list of chunks. Returns NULL if the given chunk can't be divided into chunks.

gok_chunker_add_chunkitem ()

void                gok_chunker_add_chunkitem           (GokChunk *pChunk,
                                                         GokChunkitem *pChunkitem);

Adds a chunkitem (key) to a chunk (group). The new chunkitem will be added as the last chunkitem in the list.

pChunk :

Pointer to the chunk that will contain the new chunkitem.

pChunkitem :

Pointer to the chunkitem that gets added to the chunk.

gok_chunker_count_chunkitems ()

gint                gok_chunker_count_chunkitems        (GokChunk *pChunk);

Counts the number of items in the given chunk.

pChunk :

Pointer to the Chunk that will be counted.

Returns :

The number of items in the chunk.

gok_chunker_make_2_vertical ()

GokChunk *          gok_chunker_make_2_vertical         (GokChunk *pChunk);

Creates 2 chunks that split the given chunk vertically.

pChunk :

Pointer to the chunk that will be split.

Returns :

A pointer to the first chunk, NULL if it couldn't be created.

gok_chunker_make_2_horizontal ()

GokChunk *          gok_chunker_make_2_horizontal       (GokChunk *pChunk);

Create 2 chunks that split the given chunk horizontally.

pChunk :

Pointer to the chunks that will be split.

Returns :

A pointer to the first chunk, NULL if none could be created.

gok_chunker_make_4 ()

GokChunk *          gok_chunker_make_4                  (GokChunk *pChunk);

Create 4 chunks from the given chunk. The 4 chunks are ordered like: 1 2 3 4

pChunk :

Pointer to the first in a list of chunks that will be split.

Returns :

A pointer to the first chunk, NULL if none could be created.

gok_chunker_highlight_chunk_number ()

void                gok_chunker_highlight_chunk_number  (gint Number);

Highlight the chunk identified by a number.

Number :

Id number of the chunk you want highlighted.

gok_chunker_get_chunk ()

GokChunk *          gok_chunker_get_chunk               (gint Number);

Finds a child chunk of the currently highlighted chunk.

Number :

Number of the chunk you are looking for.

Returns :

A pointer to the chunk, NULL if not found.

gok_chunker_highlight_all_keys ()

void                gok_chunker_highlight_all_keys      (void);

Highlightes all keys on the current keyboard.


gok_chunker_unhighlight_all_keys ()

void                gok_chunker_unhighlight_all_keys    (void);

Unhighlightes all keys on the current keyboard.


gok_chunker_resolve_overlap ()

void                gok_chunker_resolve_overlap         (GokChunk *pChunk);

If one of the chunks has more than one item, move an item to another chunk.

pChunk :

Pointer to the list of chunke sthat need to be resolved.