Changeset 4399

Show
Ignore:
Timestamp:
10/03/06 10:02:09 (2 years ago)
Author:
morris
Message:

Same cleanups for wire

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • wire/trunk/wire/chats.c

    r4385 r4399  
    4444         
    4545        wr_cid_t                                                cid; 
    46         wi_list_t                                              *users_list; 
     46        wi_array_t                                             *users_array; 
    4747        wi_hash_t                                               *users_hash; 
    4848};   
    …… 
    7272 
    7373 
    74 void wr_init_chats(void) { 
     74void wr_chats_init(void) { 
    7575        wr_chat_runtime_id = wi_runtime_register_class(&wr_chat_runtime_class); 
    7676 
    …… 
    8383 
    8484 
    85 void wr_clear_chats(void) { 
     85void wr_chats_clear(void) { 
    8686        wi_hash_remove_all_data(wr_chats); 
    8787        wr_chat_remove_all_users(wr_public_chat); 
    …… 
    125125 
    126126wr_chat_t * wr_chat_init(wr_chat_t *chat) { 
    127         chat->users_list       = wi_list_init(wi_list_alloc()); 
     127        chat->users_array      = wi_array_init(wi_array_alloc()); 
    128128        chat->users_hash        = wi_hash_init(wi_hash_alloc()); 
    129129         
    …… 
    151151        wr_chat_t               *chat = instance; 
    152152         
    153         wi_release(chat->users_list); 
     153        wi_release(chat->users_array); 
    154154        wi_release(chat->users_hash); 
    155155} 
    …… 
    173173                chat, 
    174174                chat->cid, 
    175                 chat->users_list); 
     175                chat->users_array); 
    176176} 
    177177 
    …… 
    202202 
    203203 
    204 wi_list_t * wr_chat_users(wr_chat_t *chat) { 
    205         return chat->users_list; 
     204wi_array_t * wr_chat_users(wr_chat_t *chat) { 
     205        return chat->users_array; 
    206206} 
    207207 
    …… 
    211211 
    212212void wr_chat_add_user(wr_chat_t *chat, wr_user_t *user) { 
    213         wi_list_append_data(chat->users_list, user); 
     213        wi_array_add_data(chat->users_array, user); 
    214214        wi_hash_set_data_for_key(chat->users_hash, user, wi_number_with_int32(wr_user_id(user))); 
    215215} 
    …… 
    218218 
    219219void wr_chat_remove_user(wr_chat_t *chat, wr_user_t *user) { 
    220         wi_list_remove_data(chat->users_list, user); 
     220        wi_array_remove_data(chat->users_array, user); 
    221221        wi_hash_remove_data_for_key(chat->users_hash, wi_number_with_int32(wr_user_id(user))); 
    222222} 
    …… 
    225225 
    226226void wr_chat_remove_all_users(wr_chat_t *chat) { 
    227         wi_list_remove_all_data(chat->users_list); 
     227        wi_array_remove_all_data(chat->users_array); 
    228228        wi_hash_remove_all_data(chat->users_hash); 
    229229} 
    …… 
    247247        free(cname); 
    248248 
    249         enumerator = wi_list_data_enumerator(chat->users_list); 
     249        enumerator = wi_array_data_enumerator(chat->users_array); 
    250250         
    251251        while((user = wi_enumerator_next_data(enumerator))) { 

  • wire/trunk/wire/chats.h

    r4385 r4399  
    3737 
    3838 
    39 void                                                            wr_init_chats(void); 
    40 void                                                            wr_clear_chats(void); 
     39void                                                            wr_chats_init(void); 
     40void                                                            wr_chats_clear(void); 
    4141 
    4242void                                                            wr_chats_add_chat(wr_chat_t *); 
    …… 
    5252 
    5353wr_cid_t                                                        wr_chat_id(wr_chat_t *); 
    54 wi_list_t *                                                   wr_chat_users(wr_chat_t *); 
     54wi_array_t *                                                  wr_chat_users(wr_chat_t *); 
    5555 
    5656void                                                            wr_chat_add_user(wr_chat_t *, wr_user_t *); 

  • wire/trunk/wire/client.c

    r4393 r4399  
    156156 
    157157 
    158 void wr_init_client(void) { 
     158void wr_client_init(void) { 
    159159        int                     options; 
    160160         
    …… 
    268268        wi_release(wr_address); 
    269269 
    270         wr_clear_windows(); 
    271         wr_clear_chats(); 
    272         wr_clear_files(); 
    273         wr_clear_transfers(); 
    274         wr_clear_users(); 
     270        wr_windows_clear(); 
     271        wr_chats_clear(); 
     272        wr_files_clear(); 
     273        wr_transfers_clear(); 
     274        wr_users_clear(); 
    275275 
    276276        wr_connected = false; 

  • wire/trunk/wire/client.h

    r4385 r4399  
    5050 
    5151 
    52 void                                                                    wr_init_client(void); 
     52void                                                                    wr_client_init(void); 
    5353 
    5454void                                                                    wr_connect(wi_string_t *, unsigned int, wi_string_t *, wi_string_t *); 

  • wire/trunk/wire/commands.c

    r4388 r4399  
    823823                                wr_ignore_string(ignore)); 
    824824                         
    825                         wi_list_append_data(wr_ignores, ignore); 
     825                        wi_array_add_data(wr_ignores, ignore); 
    826826                        wi_release(ignore); 
    827827                } else { 
    …… 
    832832                wr_printf_prefix(WI_STR("Ignores:")); 
    833833 
    834                 if(wi_list_count(wr_ignores) == 0) { 
     834                if(wi_array_count(wr_ignores) == 0) { 
    835835                        wr_printf_block(WI_STR("(none)")); 
    836836                } else { 
    837                         enumerator = wi_list_data_enumerator(wr_ignores); 
     837                        enumerator = wi_array_data_enumerator(wr_ignores); 
    838838                         
    839839                        while((ignore = wi_enumerator_next_data(enumerator))) 
    …… 
    944944 
    945945static void wr_cmd_ls(wi_array_t *arguments) { 
    946         wr_clear_files(); 
     946        wr_files_clear(); 
    947947        wr_ls_state = WR_LS_LISTING; 
    948948 
    …… 
    14111411 
    14121412static void wr_cmd_search(wi_array_t *arguments) { 
    1413         wr_clear_files(); 
     1413        wr_files_clear(); 
    14141414         
    14151415        wr_send_command(WI_STR("SEARCH %#@"), WI_ARRAY(arguments, 0)); 
    …… 
    16831683                                wr_ignore_string(ignore)); 
    16841684                         
    1685                         wi_list_remove_data(wr_ignores, ignore); 
     1685                        wi_array_remove_data(wr_ignores, ignore); 
    16861686                } else { 
    16871687                        wr_printf_prefix(WI_STR("No ignore matching \"%@\""), string); 
    …… 
    16901690                wr_printf_prefix(WI_STR("Ignores:")); 
    16911691 
    1692                 if(wi_list_count(wr_ignores) == 0) { 
     1692                if(wi_array_count(wr_ignores) == 0) { 
    16931693                        wr_printf_block(WI_STR("(none)")); 
    16941694                } else { 
    1695                         enumerator = wi_list_data_enumerator(wr_ignores); 
     1695                        enumerator = wi_array_data_enumerator(wr_ignores); 
    16961696                         
    16971697                        while((ignore = wi_enumerator_next_data(enumerator))) 

  • wire/trunk/wire/files.c

    r4384 r4399  
    8888 
    8989 
    90 void wr_init_files(void) { 
     90void wr_files_init(void) { 
    9191        wr_file_runtime_id = wi_runtime_register_class(&wr_file_runtime_class); 
    9292 
    …… 
    9898 
    9999 
    100 void wr_clear_files(void) { 
     100void wr_files_clear(void) { 
    101101        wi_array_remove_all_data(wr_files); 
    102102         
    …… 
    129129                index                   = 0; 
    130130 
    131                 wr_clear_files(); 
     131                wr_files_clear(); 
    132132                wr_send_command(WI_STR("LIST %@"), full_path); 
    133133                wr_runloop_run_for_socket(wr_socket, 3.0, 411); 
    …… 
    267267        array = wi_array_init_with_capacity(wi_array_alloc(), gl.gl_pathc); 
    268268         
    269         for(i = 0; i < (uint32_t) gl.gl_pathc; i++) 
     269        for(i = 0; i < gl.gl_pathc; i++) 
    270270                wi_array_add_data(array, wi_string_with_cstring(gl.gl_pathv[i])); 
    271271         
    …… 
    286286         
    287287        wr_ls_state = WR_LS_GLOBBING; 
    288         wr_clear_files(); 
     288        wr_files_clear(); 
    289289        wr_send_command(WI_STR("LIST %@"), dir->path); 
    290290        wr_runloop_run_for_socket(wr_socket, 3.0, 411); 

  • wire/trunk/wire/files.h

    r4384 r4399  
    5757 
    5858 
    59 void                                                            wr_init_files(void); 
    60 void                                                            wr_clear_files(void); 
     59void                                                            wr_files_init(void); 
     60void                                                            wr_files_clear(void); 
    6161 
    6262char *                                                          wr_readline_filename_generator(const char *, int); 

  • wire/trunk/wire/ignores.c

    r4384 r4399  
    4848 
    4949 
    50 wi_list_t                                                     *wr_ignores; 
     50wi_array_t                                                    *wr_ignores; 
    5151 
    5252static wi_runtime_id_t                          wr_ignore_runtime_id = WI_RUNTIME_ID_NULL; 
    …… 
    6161 
    6262 
    63 void wr_init_ignores(void) { 
     63void wr_ignores_init(void) { 
    6464        wr_ignore_runtime_id = wi_runtime_register_class(&wr_ignore_runtime_class); 
    6565 
    66         wr_ignores = wi_list_init(wi_list_alloc()); 
     66        wr_ignores = wi_array_init(wi_array_alloc()); 
    6767} 
    6868 
    …… 
    7373        wr_ignore_t             *ignore; 
    7474         
    75         enumerator = wi_list_data_enumerator(wr_ignores); 
     75        enumerator = wi_array_data_enumerator(wr_ignores); 
    7676         
    7777        while((ignore = wi_enumerator_next_data(enumerator))) { 
    …… 
    8888 
    8989char * wr_readline_ignore_generator(const char *text, int state) { 
    90         static wi_list_node_t  *node; 
     90        static uint32_t                        index; 
    9191        wi_string_t                             *name; 
    9292        wr_ignore_t                             *ignore; 
    93         char                                   *match = NULL; 
     93        uint32_t                               count; 
    9494         
    9595        if(state == 0) 
    96                 node = wi_list_first_node(wr_ignores); 
     96                index = 0; 
    9797 
    9898        name = wi_string_with_cstring(text); 
    99          
    100         while(node) { 
    101                ignore = wi_list_node_data(node); 
    102                 node = wi_list_node_next_node(node); 
     99        count = wi_array_count(wr_ignores); 
     100         
     101        while(index < count) { 
     102                ignore = WI_ARRAY(wr_ignores, index++); 
    103103                 
    104                 if(wi_string_index_of_string(ignore->string, name, WI_STRING_SMART_CASE_INSENSITIVE) == 0) { 
    105                         match = strdup(wi_string_cstring(ignore->string)); 
    106                          
    107                         break; 
    108                 } 
    109         } 
    110          
    111         return match; 
     104                if(wi_string_index_of_string(ignore->string, name, WI_STRING_SMART_CASE_INSENSITIVE) == 0) 
     105                        return strdup(wi_string_cstring(ignore->string)); 
     106        } 
     107         
     108        return NULL; 
    112109} 
    113110 
    …… 
    147144        wr_ignore_t             *ignore; 
    148145 
    149         if(wi_list_count(wr_ignores) > 0) { 
    150                 ignore = wi_list_last_data(wr_ignores); 
     146        if(wi_array_count(wr_ignores) > 0) { 
     147                ignore = wi_array_last_data(wr_ignores); 
    151148                 
    152149                return ignore->iid + 1; 
    …… 
    184181        wr_ignore_t                     *ignore, *value = NULL; 
    185182 
    186         enumerator = wi_list_data_enumerator(wr_ignores); 
     183        enumerator = wi_array_data_enumerator(wr_ignores); 
    187184         
    188185        while((ignore = wi_enumerator_next_data(enumerator))) { 
    …… 
    203200        wr_ignore_t                     *ignore; 
    204201         
    205         enumerator = wi_list_data_enumerator(wr_ignores); 
     202        enumerator = wi_array_data_enumerator(wr_ignores); 
    206203         
    207204        while((ignore = wi_enumerator_next_data(enumerator))) { 

  • wire/trunk/wire/ignores.h

    r4028 r4399  
    3535 
    3636 
    37 void                                                            wr_init_ignores(void); 
     37void                                                            wr_ignores_init(void); 
    3838wi_boolean_t                                            wr_is_ignored(wi_string_t *); 
    3939 
    …… 
    5151 
    5252 
    53 extern wi_list_t                                      *wr_ignores; 
     53extern wi_array_t                                     *wr_ignores; 
    5454 
    5555#endif /* WR_IGNORES_H */ 

  • wire/trunk/wire/main.c

    r4393 r4399  
    5252static void                                                     wr_version(void); 
    5353 
    54 static void                                                     wr_init_signals(void); 
     54static void                                                     wr_signals_init(void); 
    5555static void                                                     wr_sig_winch(int); 
    5656static void                                                     wr_sig_int(int); 
    …… 
    8585         
    8686        /* init core systems */ 
    87         wr_init_version(); 
     87        wr_version_init(); 
    8888        wr_start_date           = wi_date_init(wi_date_alloc()); 
    8989         
    …… 
    129129         
    130130        /* init subsystems */ 
    131         wr_init_signals(); 
    132         wr_init_terminal(); 
    133         wr_init_readline(); 
    134         wr_init_chats(); 
    135         wr_init_windows(); 
    136         wr_init_client(); 
    137         wr_init_runloop(); 
    138         wr_init_users(); 
    139         wr_init_ignores(); 
    140         wr_init_files(); 
    141         wr_init_transfers(); 
    142         wr_init_server(); 
     131        wr_signals_init(); 
     132        wr_terminal_init(); 
     133        wr_readline_init(); 
     134        wr_chats_init(); 
     135        wr_windows_init(); 
     136        wr_client_init(); 
     137        wr_runloop_init(); 
     138        wr_users_init(); 
     139        wr_ignores_init(); 
     140        wr_files_init(); 
     141        wr_transfers_init(); 
     142        wr_servers_init(); 
    143143         
    144144        /* open default settings */ 
    …… 
    179179 
    180180static void wr_cleanup(void) { 
    181         wr_close_terminal(); 
    182         wr_close_readline(); 
     181        wr_terminal_close(); 
     182        wr_readline_close(); 
    183183} 
    184184 
    …… 
    217217#pragma mark - 
    218218 
    219 static void wr_init_signals(void) { 
     219static void wr_signals_init(void) { 
    220220        signal(SIGPIPE, SIG_IGN); 
    221221        signal(SIGWINCH, wr_sig_winch); 
    …… 
    300300#pragma mark - 
    301301 
    302 void wr_init_runloop(void) { 
     302void wr_runloop_init(void) { 
    303303        wr_runloop_sockets = wi_array_init(wi_array_alloc()); 
    304304} 

  • wire/trunk/wire/main.h

    r3566 r4399  
    5252char *                                                                  wr_readline_bookmark_generator(const char *, int); 
    5353 
    54 void                                                                    wr_init_runloop(void); 
     54void                                                                    wr_runloop_init(void); 
    5555 
    5656void                                                                    wr_runloop_add_socket(wi_socket_t *, wr_runloop_callback_func_t *); 

  • wire/trunk/wire/server.c

    r4028 r4399  
    4747 
    4848 
    49 void wr_init_server(void) { 
     49void wr_servers_init(void) { 
    5050        wr_server_runtime_id = wi_runtime_register_class(&wr_server_runtime_class); 
    5151} 

  • wire/trunk/wire/server.h

    r3566 r4399  
    4444 
    4545 
    46 void                                                            wr_init_server(void); 
     46void                                                            wr_servers_init(void); 
    4747 
    4848wr_server_t *                                           wr_server_alloc(void); 

  • wire/trunk/wire/terminal.c

    r4373 r4399  
    6262 
    6363 
    64 void wr_init_terminal(void) { 
     64void wr_terminal_init(void) { 
    6565        wi_size_t               size; 
    6666         
    …… 
    7474 
    7575 
    76 void wr_close_terminal(void) { 
     76void wr_terminal_close(void) { 
    7777        wi_terminal_close(wr_terminal); 
    7878} 
    …… 
    9191 
    9292        wi_terminal_set_size(wr_terminal, size); 
    93         wi_terminal_set_scroll(wr_terminal, wi_make_range(1 + wi_list_count(wr_transfers), size.height - 3)); 
     93        wi_terminal_set_scroll(wr_terminal, wi_make_range(1 + wi_array_count(wr_transfers), size.height - 3)); 
    9494         
    9595        wi_terminal_clear_screen(wr_terminal); 
    …… 
    140140#pragma mark - 
    141141 
    142 void wr_init_readline(void) { 
     142void wr_readline_init(void) { 
    143143        rl_initialize(); 
    144144        using_history(); 
    …… 
    171171 
    172172 
    173 void wr_close_readline(void) { 
     173void wr_readline_close(void) { 
    174174        rl_callback_handler_remove(); 
    175175} 

  • wire/trunk/wire/terminal.h

    r3566 r4399  
    3030#define WR_TERM_H 1 
    3131 
    32 void                                                                    wr_init_terminal(void); 
    33 void                                                                    wr_close_terminal(void); 
     32void                                                                    wr_terminal_init(void); 
     33void                                                                    wr_terminal_close(void); 
    3434 
    3535void                                                                    wr_terminal_resize(void); 
    …… 
    3838void                                                                    wr_terminal_reset_location(void); 
    3939 
    40 void                                                                    wr_init_readline(void); 
    41 void                                                                    wr_close_readline(void); 
     40void                                                                    wr_readline_init(void); 
     41void                                                                    wr_readline_close(void); 
    4242 
    4343void                                                                    wr_readline_read(void); 

  • wire/trunk/wire/transfers.c

    r4384 r4399  
    4343 
    4444 
    45 wi_list_t                                                     *wr_transfers; 
     45wi_array_t                                                    *wr_transfers; 
    4646 
    4747static wi_runtime_id_t                          wr_transfer_runtime_id = WI_RUNTIME_ID_NULL; 
    …… 
    5757 
    5858 
    59 void wr_init_transfers(void) { 
     59void wr_transfers_init(void) { 
    6060        wr_transfer_runtime_id = wi_runtime_register_class(&wr_transfer_runtime_class); 
    6161 
    62         wr_transfers = wi_list_init(wi_list_alloc()); 
    63 } 
    64  
    65  
    66  
    67 void wr_clear_transfers(void) { 
    68         wi_list_remove_all_data(wr_transfers); 
     62        wr_transfers = wi_array_init(wi_array_alloc()); 
     63} 
     64 
     65 
     66 
     67void wr_transfers_clear(void) { 
     68        wi_array_remove_all_data(wr_transfers); 
    6969} 
    7070 
    …… 
    204204        } 
    205205         
    206         wi_list_append_data(wr_transfers, transfer); 
     206        wi_array_add_data(wr_transfers, transfer); 
    207207         
    208208        if(transfer->tid == 1) 
    …… 
    241241        transfer->checksum = wi_retain(wi_file_sha1(transfer->local_path, WR_CHECKSUM_SIZE)); 
    242242         
    243         wi_list_append_data(wr_transfers, transfer); 
     243        wi_array_add_data(wr_transfers, transfer); 
    244244         
    245245        if(transfer->tid == 1) 
    …… 
    308308        wr_transfer_t           *transfer; 
    309309 
    310         if(wi_list_count(wr_transfers) > 0) { 
    311                 transfer = wi_list_last_data(wr_transfers); 
     310        if(wi_array_count(wr_transfers) > 0) { 
     311                transfer = wi_array_last_data(wr_transfers); 
    312312                 
    313313                return transfer->tid + 1; 
    …… 
    338338 
    339339void wr_transfer_stop(wr_transfer_t *transfer) { 
    340         wi_list_remove_data(wr_transfers, transfer); 
    341  
    342         transfer = wi_list_first_data(wr_transfers); 
     340        wi_array_remove_data(wr_transfers, transfer); 
     341 
     342        transfer = wi_array_first_data(wr_transfers); 
    343343 
    344344        if(transfer) { 
    …… 
    359359        wr_transfer_t   *transfer; 
    360360 
    361         enumerator = wi_list_data_enumerator(wr_transfers); 
     361        enumerator = wi_array_data_enumerator(wr_transfers); 
    362362         
    363363        while((transfer = wi_enumerator_next_data(enumerator))) { 
    …… 
    375375        wr_transfer_t   *transfer; 
    376376 
    377         enumerator = wi_list_data_enumerator(wr_transfers); 
     377        enumerator = wi_array_data_enumerator(wr_transfers); 
    378378         
    379379        while((transfer = wi_enumerator_next_data(enumerator))) { 
    …… 
    391391        wr_transfer_t   *transfer; 
    392392 
    393         enumerator = wi_list_data_enumerator(wr_transfers); 
     393        enumerator = wi_array_data_enumerator(wr_transfers); 
    394394         
    395395        while((transfer = wi_enumerator_next_data(enumerator))) { 

  • wire/trunk/wire/transfers.h

    r4384 r4399  
    7878 
    7979 
    80 void                                                            wr_init_transfers(void); 
    81 void                                                            wr_clear_transfers(void); 
     80void                                                            wr_transfers_init(void); 
     81void                                                            wr_transfers_clear(void); 
    8282 
    8383int                                                                     wr_runloop_download_callback(wi_socket_t *); 
    …… 
    100100 
    101101 
    102 extern wi_list_t                                      *wr_transfers; 
     102extern wi_array_t                                     *wr_transfers; 
    103103 
    104104#endif /* WR_TRANSFERS_H */ 

  • wire/trunk/wire/users.c

    r4384 r4399  
    7171 
    7272 
    73 void wr_init_users(void) { 
     73void wr_users_init(void) { 
    7474        wr_user_runtime_id = wi_runtime_register_class(&wr_user_runtime_class); 
    7575} 
    …… 
    7777 
    7878 
    79 void wr_clear_users(void) { 
     79void wr_users_clear(void) { 
    8080        wr_reply_uid = 0; 
    8181} 
    …… 
    8686 
    8787char * wr_readline_nickname_generator(const char *text, int state) { 
    88         static wi_list_node_t   *node; 
     88        static uint32_t                 index; 
     89        wi_array_t                              *users; 
    8990        wi_string_t                             *name; 
    90         char                                    *cname, *match = NULL; 
     91        char                                    *cname; 
    9192        wr_user_t                               *user; 
     93        uint32_t                                count; 
    9294         
    9395        if(!wr_window_is_chat(wr_current_window)) 
    9496                return NULL; 
    9597         
     98        users = wr_chat_users(wr_console_window->chat); 
     99         
    96100        if(state == 0) 
    97                 node = wi_list_first_node(wr_chat_users(wr_console_window->chat)); 
     101                index = 0; 
    98102 
    99103        cname = ((*rl_filename_dequoting_function) ((char *) text, 0)); 
    100104        name = wi_string_with_cstring(cname); 
    101  
    102         while(node) { 
    103                 user = wi_list_node_data(node); 
    104                 node = wi_list_node_next_node(node); 
     105        free(cname); 
     106         
     107        count = wi_array_count(users); 
     108         
     109        while(index < count) { 
     110                user = WI_ARRAY(users, index++); 
    105111                 
    106                 if(wi_string_index_of_string(user->nick, name, WI_STRING_SMART_CASE_INSENSITIVE) == 0) { 
    107                         match = strdup(wi_string_cstring(user->nick)); 
    108                          
    109                         break; 
    110                 } 
     112                if(wi_string_index_of_string(user->nick, name, WI_STRING_SMART_CASE_INSENSITIVE) == 0) 
     113                        return strdup(wi_string_cstring(user->nick)); 
    111114        } 
    112  
    113         free(cname); 
    114          
    115         return match; 
     115         
     116        return NULL; 
    116117} 
    117118 

  • wire/trunk/wire/users.h

    r4384 r4399  
    3636 
    3737 
    38 void                                                            wr_init_users(void); 
    39 void                                                            wr_clear_users(void); 
     38void                                                            wr_users_init(void); 
     39void                                                            wr_users_clear(void); 
    4040 
    4141char *                                                          wr_readline_nickname_generator(const char *, int); 

  • wire/trunk/wire/version.c

    r4020 r4399  
    4040 
    4141 
    42 void wr_init_version(void) { 
     42void wr_version_init(void) { 
    4343        wr_version_string                       = wi_string_init_with_cstring(wi_string_alloc(), WR_VERSION); 
    4444        wr_protocol_version_string      = wi_string_init_with_cstring(wi_string_alloc(), WR_PROTOCOL_VERSION); 

  • wire/trunk/wire/version.h

    r3566 r4399  
    3535 
    3636 
    37 void                                                                    wr_init_version(void); 
     37void                                                                    wr_version_init(void); 
    3838 
    3939#endif /* WR_VERSION_H */ 

  • wire/trunk/wire/windows.c

    r4386 r4399  
    4444 
    4545 
    46 wi_list_t                                                     *wr_windows; 
     46wi_array_t                                                    *wr_windows; 
    4747 
    4848wr_window_t                                                     *wr_console_window; 
    …… 
    6060 
    6161 
    62 void wr_init_windows(void) { 
     62void wr_windows_init(void) { 
    6363        wr_window_runtime_id = wi_runtime_register_class(&wr_window_runtime_class); 
    6464 
    65         wr_windows = wi_list_init(wi_list_alloc()); 
     65        wr_windows = wi_array_init(wi_array_alloc()); 
    6666 
    6767        wr_console_window = wr_window_init_with_chat(wr_window_alloc(), wr_public_chat); 
    …… 
    7373 
    7474 
    75 void wr_clear_windows(void) { 
    76         wi_list_node_t  *node, *next_node; 
     75void wr_windows_clear(void) { 
    7776        wr_window_t             *window; 
    78  
    79         for(node = wi_list_first_node(wr_windows); node; node = next_node) { 
    80                 next_node       = wi_list_node_next_node(node); 
    81                 window          = wi_list_node_data(node); 
    82                  
    83                 if(window != wr_console_window) 
     77        uint32_t                i, count; 
     78 
     79        count = wi_array_count(wr_windows); 
     80         
     81        for(i = 0; i < count; i++) { 
     82                window = WI_ARRAY(wr_windows, i); 
     83                 
     84                if(window != wr_console_window) { 
    8485                        wr_windows_close_window(window); 
     86                         
     87                        i--; 
     88                        count--; 
     89                } 
    8590        } 
    8691         
    …… 
    9297#pragma mark - 
    9398 
    94 wr_window_t * wr_window_alloc(void) { 
    95         return wi_runtime_create_instance(wr_window_runtime_id, sizeof(wr_window_t)); 
    96 } 
    97  
    98  
    99  
    100 wr_window_t * wr_window_init(wr_window_t *window) { 
    101         window->buffer          = wi_terminal_buffer_init_with_terminal(wi_terminal_buffer_alloc(), wr_terminal); 
    102         window->wid                     = wr_window_wid(); 
    103         window->status          = WR_WINDOW_STATUS_IDLE; 
    104          
    105         return window; 
    106 } 
    107  
    108  
    109  
    110 wr_window_t * wr_window_init_with_chat(wr_window_t *window, wr_chat_t *chat) { 
    111         window = wr_window_init(window); 
    112  
    113         window->type            = WR_WINDOW_TYPE_CHAT; 
    114         window->chat            = wi_retain(chat); 
    115          
    116         return window; 
    117 } 
    118  
    119  
    120  
    121 wr_window_t * wr_window_init_with_user(wr_window_t *window, wr_user_t *user) { 
    122         window = wr_window_init(window); 
    123          
    124         window->type            = WR_WINDOW_TYPE_USER; 
    125         window->user            = wi_retain(user); 
    126         window->topic.topic     = wi_retain(wr_user_nick(user)); 
    127