void wr_print_files(void) {
wi_enumerator_t *enumerator;
wr_file_t *file;
wi_uinteger_t max_length = 0;
enumerator = wi_array_data_enumerator(wr_files);
while((file = wi_enumerator_next_data(enumerator)))
max_length = WI_MAX(max_length, wi_string_length(wr_file_name(file)));
enumerator = wi_array_data_enumerator(wr_files);
while((file = wi_enumerator_next_data(enumerator)))
wr_print_file(file, false, max_length);
}
void wr_transfer_upload_remove_files(wr_transfer_t *transfer, wi_array_t *files) {
wi_enumerator_t *enumerator;
wr_file_t *file;
wi_uinteger_t i, count;
count = wi_array_count(transfer->remote_paths);
enumerator = wi_array_data_enumerator(files);
while((file = wi_enumerator_next_data(enumerator))) {
for(i = 0; i < count; i++) {
if(wi_is_equal(wr_file_path(file), WI_ARRAY(transfer->remote_paths, i))) {
transfer->total_size -= wr_file_size(WI_ARRAY(transfer->files, i));
wi_mutable_array_remove_data_at_index(transfer->remote_paths, i);
wi_mutable_array_remove_data_at_index(transfer->local_paths, i);
wi_mutable_array_remove_data_at_index(transfer->files, i);
count--;
break;
}
}
}
wr_transfers_recursive_upload = false;
}
void wd_broadcast(wd_chat_t *chat, uint32_t n, wi_string_t *fmt, ...) {
wi_enumerator_t *enumerator;
wi_string_t *string;
wi_array_t *users;
wd_user_t *user;
va_list ap;
va_start(ap, fmt);
string = wi_string_init_with_format_and_arguments(wi_string_alloc(), fmt, ap);
va_end(ap);
users = wd_chat_users(chat);
wi_array_rdlock(users);
enumerator = wi_array_data_enumerator(users);
while((user = wi_enumerator_next_data(enumerator))) {
if(wd_user_state(user) == WD_USER_LOGGED_IN) {
wd_user_lock_socket(user);
wi_socket_write_format(wd_user_socket(user), 0.0, WI_STR("%u %@%c"), n, string, WD_MESSAGE_SEPARATOR);
wd_user_unlock_socket(user);
}
}
wi_array_unlock(users);
wi_release(string);
}
static wi_mutable_array_t * _wi_terminal_buffer_lines_for_string(wi_terminal_buffer_t *buffer, wi_string_t *string) {
wi_enumerator_t *enumerator;
wi_mutable_array_t *array;
wi_mutable_string_t *newstring;
wi_string_t *line, *subline;
wi_size_t size;
wi_uinteger_t index;
array = wi_array_init(wi_mutable_array_alloc());
size = wi_terminal_size(buffer->terminal);
enumerator = wi_array_data_enumerator(wi_string_components_separated_by_string(string, WI_STR("\n")));
while((line = wi_enumerator_next_data(enumerator))) {
if(wi_terminal_width_of_string(buffer->terminal, line) < size.width) {
wi_mutable_array_add_data(array, line);
} else {
newstring = wi_mutable_copy(line);
do {
index = wi_terminal_index_of_string_for_width(buffer->terminal, newstring, size.width);
subline = wi_string_substring_to_index(newstring, index);
wi_mutable_array_add_data(array, subline);
wi_mutable_string_delete_characters_to_index(newstring, wi_string_length(subline));
} while(wi_terminal_width_of_string(buffer->terminal, newstring) >= size.width);
wi_mutable_array_add_data(array, newstring);
wi_release(newstring);
}
}
return wi_autorelease(array);
}
static void wd_trackers_register_thread(wi_runtime_instance_t *argument) {
wi_pool_t *pool;
wi_enumerator_t *enumerator;
wi_number_t *number = argument;
wd_tracker_t *tracker;
wi_boolean_t update;
pool = wi_pool_init(wi_pool_alloc());
update = wi_number_bool(number);
wi_array_rdlock(wd_trackers);
enumerator = wi_array_data_enumerator(wd_trackers);
while((tracker = wi_enumerator_next_data(enumerator))) {
wd_tracker_register(tracker);
if(update && tracker->active)
wd_tracker_update(tracker);
}
wi_array_unlock(wd_trackers);
if(update)
wi_timer_reschedule(wd_trackers_update_timer, WD_TRACKERS_UPDATE_INTERVAL);
wi_release(pool);
}
static void wr_command_invite(wi_array_t *arguments) {
wi_enumerator_t *enumerator;
wi_p7_message_t *message;
wi_string_t *nick;
wr_user_t *user;
wr_chat_t *chat;
if(!wr_window_is_private_chat(wr_current_window)) {
wr_printf_prefix(WI_STR("invite: Current window is not a private chat"));
return;
}
chat = wr_window_chat(wr_current_window);
enumerator = wi_array_data_enumerator(arguments);
while((nick = wi_enumerator_next_data(enumerator))) {
user = wr_chat_user_with_nick(wr_public_chat, nick);
if(!user) {
wr_printf_prefix(WI_STR("invite: %@: Client not found"),
nick);
continue;
}
message = wi_p7_message_with_name(WI_STR("wired.chat.invite_user"), wr_p7_spec);
wi_p7_message_set_uint32_for_name(message, wr_user_id(user), WI_STR("wired.user.id"));
wi_p7_message_set_uint32_for_name(message, wr_chat_id(chat), WI_STR("wired.chat.id"));
wr_commands_send_message(message, WI_STR("invite"));
}
}
static void wr_command_ignore(wi_array_t *arguments) {
wi_enumerator_t *enumerator;
wi_string_t *string;
wr_ignore_t *ignore;
if(wi_array_count(arguments) > 0) {
string = WI_ARRAY(arguments, 0);
ignore = wr_ignore_init_with_string(wr_ignore_alloc(), string);
if(ignore) {
wr_printf_prefix(WI_STR("Ignoring \"%@\""),
wr_ignore_string(ignore));
wi_mutable_array_add_data(wr_ignores, ignore);
wi_release(ignore);
} else {
wr_printf_prefix(WI_STR("ignore: Could not compile regular expression \"%@\": %m"),
string);
}
} else {
wr_printf_prefix(WI_STR("Ignores:"));
if(wi_array_count(wr_ignores) == 0) {
wr_printf_block(WI_STR("(none)"));
} else {
enumerator = wi_array_data_enumerator(wr_ignores);
while((ignore = wi_enumerator_next_data(enumerator)))
wr_printf_block(WI_STR("%u: %@"), wr_ignore_id(ignore), wr_ignore_string(ignore));
}
}
}
void wd_chat_reply_user_list(wd_chat_t *chat) {
wi_enumerator_t *enumerator;
wd_user_t *user;
wi_array_rdlock(chat->users);
enumerator = wi_array_data_enumerator(chat->users);
while((user = wi_enumerator_next_data(enumerator))) {
if(wd_user_state(user) == WD_USER_LOGGED_IN) {
wd_reply(310, WI_STR("%u%c%u%c%u%c%u%c%u%c%#@%c%#@%c%#@%c%#@%c%#@%c%#@"),
chat->cid, WD_FIELD_SEPARATOR,
wd_user_uid(user), WD_FIELD_SEPARATOR,
wd_user_is_idle(user), WD_FIELD_SEPARATOR,
wd_user_is_admin(user), WD_FIELD_SEPARATOR,
wd_user_icon(user), WD_FIELD_SEPARATOR,
wd_user_nick(user), WD_FIELD_SEPARATOR,
wd_user_login(user), WD_FIELD_SEPARATOR,
wd_user_ip(user), WD_FIELD_SEPARATOR,
wd_user_host(user), WD_FIELD_SEPARATOR,
wd_user_status(user), WD_FIELD_SEPARATOR,
wd_user_image(user));
}
}
wi_array_unlock(chat->users);
wd_reply(311, WI_STR("%u"), chat->cid);
}
void wd_user_unsubscribe_paths(wd_user_t *user) {
wi_enumerator_t *enumerator;
wi_string_t *path;
wi_recursive_lock_lock(user->user_lock);
enumerator = wi_array_data_enumerator(wi_set_all_data(user->subscribed_paths));
while((path = wi_enumerator_next_data(enumerator))) {
wi_retain(path);
while(wi_set_contains_data(user->subscribed_paths, path)) {
if(wd_files_fsevents)
wi_fsevents_remove_path(wd_files_fsevents, path);
wi_mutable_set_remove_data(user->subscribed_paths, path);
}
wi_release(path);
}
wi_mutable_dictionary_remove_all_data(user->subscribed_virtualpaths);
wi_recursive_lock_unlock(user->user_lock);
}
void wr_draw_transfers(wi_boolean_t force) {
static wi_time_interval_t update;
wi_enumerator_t *enumerator;
wi_mutable_string_t *string;
wi_string_t *status;
wr_transfer_t *transfer;
wi_time_interval_t interval;
wi_uinteger_t i = 0;
interval = wi_time_interval();
if(!force && interval - update < 1.0)
return;
update = interval;
wi_terminal_set_scroll(wr_terminal, wi_make_range(1 + wi_array_count(wr_transfers),
wi_terminal_size(wr_terminal).height - 4));
enumerator = wi_array_data_enumerator(wr_transfers);
while((transfer = wi_enumerator_next_data(enumerator))) {
wi_terminal_move(wr_terminal, wi_make_point(0, i + 1));
wi_terminal_clear_line(wr_terminal);
if(transfer->state == WR_TRANSFER_RUNNING && interval - transfer->start_time > 0.0) {
transfer->speed = ((double) transfer->total_transferred - transfer->total_offset) / (interval - transfer->start_time);
status = wi_string_with_format(WI_STR("%@/%@, %@/s"),
wr_files_string_for_size(transfer->total_transferred),
wr_files_string_for_size(transfer->total_size),
wr_files_string_for_size(transfer->speed));
}
else if(transfer->state == WR_TRANSFER_QUEUED) {
status = wi_string_with_format(WI_STR("queued at %u"),
transfer->queue);
}
else {
status = wi_string_with_cstring("waiting");
}
string = wi_mutable_string_with_format(WI_STR("%u %3.0f%% %@"),
transfer->tid,
transfer->total_size > 0
? 100 * ((double) transfer->total_transferred / (double) transfer->total_size)
: 0,
transfer->name);
wi_terminal_adjust_string_to_fit_width(wr_terminal, string);
wi_mutable_string_delete_characters_from_index(string, wi_string_length(string) - wi_string_length(status));
wi_mutable_string_append_string(string, status);
wi_terminal_printf(wr_terminal, WI_STR("%@"), string);
i++;
}
wr_terminal_reset_location();
}
void wr_transfer_download_add_files(wr_transfer_t *transfer, wi_array_t *files) {
wi_enumerator_t *enumerator;
wr_file_t *file;
enumerator = wi_array_data_enumerator(files);
while((file = wi_enumerator_next_data(enumerator)))
wr_transfer_download_add_file(transfer, file, true);
}
void wi_terminal_set_size(wi_terminal_t *terminal, wi_size_t size) {
wi_enumerator_t *enumerator;
wi_terminal_buffer_t *buffer;
terminal->co = size.width;
terminal->li = size.height;
enumerator = wi_array_data_enumerator(terminal->buffers);
while((buffer = wi_enumerator_next_data(enumerator)))
_wi_terminal_buffer_reload(buffer);
}
wr_transfer_t * wr_transfers_transfer_with_remote_path(wi_string_t *remote_path) {
wi_enumerator_t *enumerator, *path_enumerator;
wi_string_t *path;
wr_transfer_t *transfer;
enumerator = wi_array_data_enumerator(wr_transfers);
while((transfer = wi_enumerator_next_data(enumerator))) {
if(wi_is_equal(transfer->master_path, remote_path))
return transfer;
path_enumerator = wi_array_data_enumerator(transfer->remote_paths);
while((path = wi_enumerator_next_data(path_enumerator))) {
if(wi_is_equal(path, remote_path))
return transfer;
}
}
return NULL;
}
wr_window_t * wr_windows_window_with_chat(wr_chat_t *chat) {
wi_enumerator_t *enumerator;
wr_window_t *window;
enumerator = wi_array_data_enumerator(wr_windows);
while((window = wi_enumerator_next_data(enumerator))) {
if(wr_window_is_chat(window) && wi_is_equal(window->chat, chat))
return window;
}
return NULL;
}
wr_window_t * wr_windows_window_with_user(wr_user_t *user) {
wi_enumerator_t *enumerator;
wr_window_t *window;
enumerator = wi_array_data_enumerator(wr_windows);
while((window = wi_enumerator_next_data(enumerator))) {
if(wr_window_is_user(window) && wi_is_equal(window->user, user))
return window;
}
return NULL;
}
void wr_print_users(wr_window_t *window) {
wi_enumerator_t *enumerator;
wi_array_t *users;
wr_user_t *user;
wi_uinteger_t max_length = 0;
if(window->chat == wr_public_chat)
wr_printf_prefix(WI_STR("Users currently online:"));
else
wr_printf_prefix(WI_STR("Users in chat:"));
users = wr_chat_users(window->chat);
enumerator = wi_array_data_enumerator(users);
while((user = wi_enumerator_next_data(enumerator)))
max_length = WI_MAX(max_length, wi_string_length(wr_user_nick(user)));
enumerator = wi_array_data_enumerator(users);
while((user = wi_enumerator_next_data(enumerator)))
wr_print_user(user, max_length);
}
wr_transfer_t * wr_transfers_transfer_with_socket(wi_socket_t *socket) {
wi_enumerator_t *enumerator;
wr_transfer_t *transfer;
enumerator = wi_array_data_enumerator(wr_transfers);
while((transfer = wi_enumerator_next_data(enumerator))) {
if(transfer->socket == socket)
return transfer;
}
return NULL;
}
wr_transfer_t * wr_transfers_transfer_with_tid(wr_tid_t tid) {
wi_enumerator_t *enumerator;
wr_transfer_t *transfer;
enumerator = wi_array_data_enumerator(wr_transfers);
while((transfer = wi_enumerator_next_data(enumerator))) {
if(transfer->tid == tid)
return transfer;
}
return NULL;
}
static void wd_trackers_update(void) {
wi_enumerator_t *enumerator;
wd_tracker_t *tracker;
wi_array_rdlock(wd_trackers);
enumerator = wi_array_data_enumerator(wd_trackers);
while((tracker = wi_enumerator_next_data(enumerator))) {
if(tracker->active)
wd_tracker_update(tracker);
}
wi_array_unlock(wd_trackers);
}
void wr_wprintf_block(wr_window_t *window, wi_string_t *fmt, ...) {
wi_enumerator_t *enumerator;
wi_string_t *string, *line;
va_list ap;
va_start(ap, fmt);
string = wi_string_init_with_format_and_arguments(wi_string_alloc(), fmt, ap);
va_end(ap);
enumerator = wi_array_data_enumerator(wi_string_components_separated_by_string(string, WI_STR("\n")));
while((line = wi_enumerator_next_data(enumerator)))
wr_wprintf(window, WI_STR(" %@"), line);
wi_release(string);
}
wi_boolean_t wi_terminal_buffer_printf(wi_terminal_buffer_t *buffer, wi_string_t *fmt, ...) {
wi_enumerator_t *enumerator;
wi_array_t *array;
wi_string_t *string, *line;
wi_point_t location;
va_list ap;
wi_boolean_t result = false;
va_start(ap, fmt);
string = wi_string_init_with_format_and_arguments(wi_string_alloc(), fmt, ap);
va_end(ap);
array = _wi_terminal_buffer_lines_for_string(buffer, string);
if(buffer->terminal->active_buffer == buffer) {
if(buffer->line == wi_array_count(buffer->linebuffer)) {
location = wi_terminal_location(buffer->terminal);
wi_terminal_move(buffer->terminal, wi_make_point(0, wi_terminal_scroll(buffer->terminal).length));
enumerator = wi_array_data_enumerator(array);
while((line = wi_enumerator_next_data(enumerator))) {
_wi_terminal_puts(buffer->terminal, WI_STR("\n"));
_wi_terminal_puts(buffer->terminal, line);
buffer->line++;
}
wi_terminal_move(buffer->terminal, location);
result = true;
}
}
if(wi_string_length(buffer->textbuffer) > 0)
wi_mutable_string_append_string(buffer->textbuffer, WI_STR("\n"));
wi_mutable_string_append_string(buffer->textbuffer, string);
wi_mutable_array_add_data_from_array(buffer->linebuffer, array);
wi_release(string);
return result;
}
void wd_user_broadcast_icon(wd_user_t *user) {
wi_enumerator_t *enumerator;
wi_p7_message_t *message;
wd_chat_t *chat;
enumerator = wi_array_data_enumerator(wd_chats_chats_with_user(user));
wi_recursive_lock_lock(user->user_lock);
while((chat = wi_enumerator_next_data(enumerator))) {
message = wi_p7_message_with_name(WI_STR("wired.chat.user_icon"), wd_p7_spec);
wi_p7_message_set_uint32_for_name(message, user->id, WI_STR("wired.user.id"));
wi_p7_message_set_uint32_for_name(message, wd_chat_id(chat), WI_STR("wired.chat.id"));
wi_p7_message_set_data_for_name(message, user->icon, WI_STR("wired.user.icon"));
wd_chat_broadcast_message(chat, message);
}
wi_recursive_lock_unlock(user->user_lock);
}
static void wt_update_servers(wi_timer_t *timer) {
wi_enumerator_t *enumerator;
wt_server_t *server;
void *key;
wi_time_interval_t interval, update;
wi_boolean_t changed = false;
wi_dictionary_wrlock(wt_servers);
if(wi_dictionary_count(wt_servers) > 0) {
interval = wi_time_interval();
enumerator = wi_array_data_enumerator(wi_dictionary_all_keys(wt_servers));
while((key = wi_enumerator_next_data(enumerator))) {
server = wi_dictionary_data_for_key(wt_servers, key);
update = server->update_time > 0.0 ? server->update_time : server->register_time;
if(interval - update > wt_settings.minupdatetime) {
wi_log_warn(WI_STR("Deleting \"%@\" with URL %@: Last update %.0f seconds ago considered too slow"),
server->name, server->url, interval - update);
wt_servers_remove_stats_for_server(server);
wi_dictionary_remove_data_for_key(wt_servers, key);
changed = true;
}
}
}
wi_dictionary_unlock(wt_servers);
if(changed) {
wi_lock_lock(wt_status_lock);
wt_write_status(true);
wi_lock_unlock(wt_status_lock);
wt_servers_write_file();
}
}
void wd_chats_remove_user(wd_user_t *user) {
wi_enumerator_t *enumerator;
wd_chat_t *chat;
void *key;
wi_dictionary_wrlock(wd_chats);
enumerator = wi_array_data_enumerator(wi_dictionary_all_keys(wd_chats));
while((key = wi_enumerator_next_data(enumerator))) {
chat = wi_dictionary_data_for_key(wd_chats, key);
wi_array_wrlock(chat->users);
wi_mutable_array_remove_data(chat->users, user);
wi_array_unlock(chat->users);
if(chat != wd_public_chat && wi_array_count(chat->users) == 0)
wi_mutable_dictionary_remove_data_for_key(wd_chats, key);
}
wi_dictionary_unlock(wd_chats);
}
wr_user_t * wr_chat_user_with_nick(wr_chat_t *chat, wi_string_t *nick) {
wi_enumerator_t *enumerator;
wi_string_t *name;
wr_user_t *user, *value = NULL;
char *cname;
cname = ((*rl_filename_dequoting_function) ((char *) wi_string_cstring(nick), 0));
name = wi_string_with_cstring(cname);
free(cname);
enumerator = wi_array_data_enumerator(chat->users_array);
while((user = wi_enumerator_next_data(enumerator))) {
if(wi_is_equal(wr_user_nick(user), name)) {
value = user;
break;
}
}
return value;
}
static void wr_command_info(wi_array_t *arguments) {
wi_enumerator_t *enumerator;
wi_p7_message_t *message;
wi_string_t *nick;
wr_user_t *user;
enumerator = wi_array_data_enumerator(arguments);
while((nick = wi_enumerator_next_data(enumerator))) {
user = wr_chat_user_with_nick(wr_public_chat, nick);
if(!user) {
wr_printf_prefix(WI_STR("info: %@: Client not found"),
nick);
continue;
}
message = wi_p7_message_with_name(WI_STR("wired.user.get_info"), wr_p7_spec);
wi_p7_message_set_uint32_for_name(message, wr_user_id(user), WI_STR("wired.user.id"));
wr_commands_send_message(message, WI_STR("info"));
}
}
static void wr_command_unignore(wi_array_t *arguments) {
wi_enumerator_t *enumerator;
wi_string_t *string;
wr_ignore_t *ignore;
wr_iid_t iid;
if(wi_array_count(arguments) > 0) {
string = WI_ARRAY(arguments, 0);
iid = wi_string_uint32(string);
if(iid > 0)
ignore = wr_ignore_with_iid(iid);
else
ignore = wr_ignore_with_string(string);
if(ignore) {
wr_printf_prefix(WI_STR("No longer ignoring \"%@\""),
wr_ignore_string(ignore));
wi_mutable_array_remove_data(wr_ignores, ignore);
} else {
wr_printf_prefix(WI_STR("No ignore matching \"%@\""), string);
}
} else {
wr_printf_prefix(WI_STR("Ignores:"));
if(wi_array_count(wr_ignores) == 0) {
wr_printf_block(WI_STR("(none)"));
} else {
enumerator = wi_array_data_enumerator(wr_ignores);
while((ignore = wi_enumerator_next_data(enumerator)))
wr_printf_block(WI_STR("%u: %@"), wr_ignore_id(ignore), wr_ignore_string(ignore));
}
}
}
void wd_user_broadcast_status(wd_user_t *user) {
wi_enumerator_t *enumerator;
wi_p7_message_t *message;
wd_chat_t *chat;
enumerator = wi_array_data_enumerator(wd_chats_chats_with_user(user));
wi_recursive_lock_lock(user->user_lock);
while((chat = wi_enumerator_next_data(enumerator))) {
message = wi_p7_message_with_name(WI_STR("wired.chat.user_status"), wd_p7_spec);
wi_p7_message_set_uint32_for_name(message, wd_chat_id(chat), WI_STR("wired.chat.id"));
wi_p7_message_set_uint32_for_name(message, user->id, WI_STR("wired.user.id"));
wi_p7_message_set_bool_for_name(message, user->idle, WI_STR("wired.user.idle"));
wi_p7_message_set_string_for_name(message, user->nick, WI_STR("wired.user.nick"));
wi_p7_message_set_string_for_name(message, user->status, WI_STR("wired.user.status"));
wi_p7_message_set_enum_for_name(message, user->color, WI_STR("wired.account.color"));
wi_p7_message_set_date_for_name(message, user->idle_time, WI_STR("wired.user.idle_time"));
wd_chat_broadcast_message(chat, message);
}
wi_recursive_lock_unlock(user->user_lock);
}
void wr_draw_divider(void) {
wi_enumerator_t *enumerator;
wi_mutable_string_t *string, *action;
wi_string_t *position;
wr_window_t *window;
wi_size_t size;
wi_range_t scroll;
wi_point_t location;
const char *color;
wi_uinteger_t users, line, lines, windows;
string = wi_mutable_string_with_format(WI_STR("%s%@"), WR_PREFIX, wr_nick);
if(wr_connected && wr_server) {
users = wi_array_count(wr_chat_users(wr_console_window->chat));
wi_mutable_string_append_format(string, WI_STR(" - %@ - %u %@"),
wr_server_name(wr_server),
users,
users == 1
? WI_STR("user")
: WI_STR("users"));
}
action = wi_mutable_string();
windows = 0;
enumerator = wi_array_data_enumerator(wr_windows);
while((window = wi_enumerator_next_data(enumerator))) {
switch(window->status) {
case WR_WINDOW_STATUS_ACTION:
color = WR_INTERFACE_COLOR;
break;
case WR_WINDOW_STATUS_CHAT:
color = WR_STATUS_COLOR;
break;
case WR_WINDOW_STATUS_HIGHLIGHT:
color = WR_HIGHLIGHT_COLOR;
break;
default:
color = NULL;
break;
}
if(color) {
if(windows > 0)
wi_mutable_string_append_string(action, WI_STR(","));
wi_mutable_string_append_format(action, WI_STR("%s%s%s%u%s%s"),
WR_TERMINATE_COLOR,
WR_INTERFACE_COLOR,
color,
window->wid,
WR_TERMINATE_COLOR,
WR_INTERFACE_COLOR);
windows++;
}
}
if(windows > 0)
wi_mutable_string_append_format(string, WI_STR(" [%@]"), action);
line = wi_terminal_buffer_current_line(wr_current_window->buffer);
lines = wi_terminal_buffer_lines(wr_current_window->buffer);
scroll = wi_terminal_scroll(wr_terminal);
if(lines == 0 || line == lines)
position = NULL;
else if(line <= scroll.length)
position = wi_string_with_cstring("TOP");
else
position = wi_string_with_format(WI_STR("%.0f%%"), 100 * ((double) (line - scroll.length) / (double) lines));
wi_terminal_adjust_string_to_fit_width(wr_terminal, string);
if(position) {
wi_mutable_string_delete_characters_from_index(string, wi_string_length(string) - wi_string_length(position));
wi_mutable_string_append_string(string, position);
}
size = wi_terminal_size(wr_terminal);
location = wi_terminal_location(wr_terminal);
wi_terminal_move_printf(wr_terminal, wi_make_point(0, size.height - 3), WI_STR("%s%@%s"),
WR_INTERFACE_COLOR,
string,
WR_TERMINATE_COLOR);
wi_terminal_move(wr_terminal, location);
}
wi_socket_t * wi_socket_wait_multiple(wi_array_t *array, wi_time_interval_t timeout) {
wi_enumerator_t *enumerator;
wi_socket_t *socket, *waiting_socket = NULL;
struct timeval tv;
fd_set rfds, wfds;
int state, max_sd;
tv = wi_dtotv(timeout);
max_sd = -1;
FD_ZERO(&rfds);
FD_ZERO(&wfds);
wi_array_rdlock(array);
enumerator = wi_array_data_enumerator(array);
while((socket = wi_enumerator_next_data(enumerator))) {
if(wi_string_length(socket->buffer) > 0) {
waiting_socket = socket;
break;
}
if(socket->direction & WI_SOCKET_READ)
FD_SET(socket->sd, &rfds);
if(socket->direction & WI_SOCKET_WRITE)
FD_SET(socket->sd, &wfds);
if(socket->sd > max_sd)
max_sd = socket->sd;
}
wi_array_unlock(array);
if(waiting_socket)
return waiting_socket;
state = select(max_sd + 1, &rfds, &wfds, NULL, (timeout > 0.0) ? &tv : NULL);
if(state < 0) {
wi_error_set_errno(errno);
return NULL;
}
wi_array_rdlock(array);
enumerator = wi_array_data_enumerator(array);
while((socket = wi_enumerator_next_data(enumerator))) {
if(FD_ISSET(socket->sd, &rfds) || FD_ISSET(socket->sd, &wfds)) {
waiting_socket = socket;
break;
}
}
wi_array_unlock(array);
return waiting_socket;
}
