std::string Tox_Dispatcher::get_self_status_message()
{
lock.lock();
const size_t len = tox_self_get_status_message_size(tox);
std::vector<uint8_t> msg(len, 0);
tox_self_get_status_message(tox, msg.data());
lock.unlock();
return std::string(msg.data(), msg.data() + len);
}
QString Core::getStatusMessage() const
{
QString sname;
size_t size = tox_self_get_status_message_size(tox);
uint8_t* name = new uint8_t[size];
tox_self_get_status_message(tox, name);
sname = CString::toString(name, size);
delete[] name;
return sname;
}
char *api_get_status_message(void)
{
size_t len = tox_self_get_status_message_size(user_tox);
uint8_t *status = malloc(len + 1);
if (status == NULL) {
return NULL;
}
tox_self_get_status_message(user_tox, status);
status[len] = '\0';
return (char *) status;
}
/**
* @brief Returns our status message, or an empty string on failure
*/
QString Core::getStatusMessage() const
{
QString sname;
if (!tox) {
return sname;
}
size_t size = tox_self_get_status_message_size(tox);
uint8_t* name = new uint8_t[size];
tox_self_get_status_message(tox, name);
sname = ToxString(name, size).getQString();
delete[] name;
return sname;
}
static void mplex_timer_handler (Tox *m)
{
TOX_USER_STATUS current_status, new_status;
const char *new_note;
if (mplex == MPLEX_NONE)
return;
int detached = mplex_is_detached ();
pthread_mutex_lock (&Winthread.lock);
current_status = tox_self_get_status (m);
pthread_mutex_unlock (&Winthread.lock);
if (auto_away_active && current_status == TOX_USER_STATUS_AWAY && !detached)
{
auto_away_active = false;
new_status = prev_status;
new_note = prev_note;
}
else
if (current_status == TOX_USER_STATUS_NONE && detached)
{
auto_away_active = true;
prev_status = current_status;
new_status = TOX_USER_STATUS_AWAY;
pthread_mutex_lock (&Winthread.lock);
size_t slen = tox_self_get_status_message_size(m);
tox_self_get_status_message (m, (uint8_t*) prev_note);
prev_note[slen] = '\0';
pthread_mutex_unlock (&Winthread.lock);
new_note = user_settings->mplex_away_note;
}
else
return;
char argv[3][MAX_STR_SIZE];
strcpy (argv[0], "/status");
strcpy (argv[1], (new_status == TOX_USER_STATUS_AWAY ? "away" :
new_status == TOX_USER_STATUS_BUSY ? "busy" : "online"));
argv[2][0] = '\"';
strcpy (argv[2] + 1, new_note);
strcat (argv[2], "\"");
pthread_mutex_lock (&Winthread.lock);
cmd_status (prompt->chatwin->history, prompt, m, 2, argv);
pthread_mutex_unlock (&Winthread.lock);
}
void prompt_init_statusbar(ToxWindow *self, Tox *m)
{
int x2, y2;
getmaxyx(self->window, y2, x2);
(void) y2;
/* Init statusbar info */
StatusBar *statusbar = self->stb;
statusbar->status = TOX_USER_STATUS_NONE;
statusbar->connection = TOX_CONNECTION_NONE;
char nick[TOX_MAX_NAME_LENGTH];
char statusmsg[TOX_MAX_STATUS_MESSAGE_LENGTH];
size_t n_len = tox_self_get_name_size(m);
tox_self_get_name(m, (uint8_t *) nick);
size_t s_len = tox_self_get_status_message_size(m);
tox_self_get_status_message(m, (uint8_t *) statusmsg);
TOX_USER_STATUS status = tox_self_get_status(m);
nick[n_len] = '\0';
statusmsg[s_len] = '\0';
if (s_len == 0 || !strncmp(statusmsg, "Toxing on Toxic", strlen("Toxing on Toxic"))) {
snprintf(statusmsg, sizeof(statusmsg), "Toxing on Toxic");
s_len = strlen(statusmsg);
statusmsg[s_len] = '\0';
}
prompt_update_statusmessage(prompt, m, statusmsg);
prompt_update_status(prompt, status);
prompt_update_nick(prompt, nick);
/* Init statusbar subwindow */
statusbar->topline = subwin(self->window, 2, x2, 0, 0);
}
void client_info_update(const Tox *apptox, struct client_info *own_info)
{
size_t name_size;
size_t status_message_size;
name_size = tox_self_get_name_size(apptox);
own_info->name = realloc(own_info->name, name_size * sizeof(uint8_t) + 1);
tox_self_get_name(apptox, own_info->name);
own_info->name[name_size] = '\0';
tox_self_get_address(apptox, own_info->tox_id_bin);
sodium_bin2hex(own_info->tox_id_hex, sizeof(own_info->tox_id_hex), own_info->tox_id_bin, sizeof(own_info->tox_id_bin));
for (size_t i = 0; i < sizeof(own_info->tox_id_hex) - 1; i++) {
own_info->tox_id_hex[i] = toupper(own_info->tox_id_hex[i]);
}
own_info->connect = tox_self_get_connection_status(apptox);
status_message_size = tox_self_get_status_message_size(apptox);
own_info->status_message = realloc(own_info->status_message, status_message_size * sizeof(uint8_t) + 1);
tox_self_get_status_message(apptox, own_info->status_message);
own_info->status_message[status_message_size] = '\0';
}
static void test_one(void)
{
uint8_t name[TOX_MAX_NAME_LENGTH];
uint8_t status_message[TOX_MAX_STATUS_MESSAGE_LENGTH];
uint8_t name2[TOX_MAX_NAME_LENGTH];
uint8_t status_message2[TOX_MAX_STATUS_MESSAGE_LENGTH];
uint32_t index[] = { 1, 2 };
Tox *tox1 = tox_new_log(nullptr, nullptr, &index[0]);
set_random_name_and_status_message(tox1, name, status_message);
Tox *tox2 = tox_new_log(nullptr, nullptr, &index[1]);
set_random_name_and_status_message(tox2, name2, status_message2);
uint8_t address[TOX_ADDRESS_SIZE];
tox_self_get_address(tox1, address);
Tox_Err_Friend_Add error;
uint32_t ret = tox_friend_add(tox1, address, (const uint8_t *)"m", 1, &error);
ck_assert_msg(ret == UINT32_MAX && error == TOX_ERR_FRIEND_ADD_OWN_KEY, "Adding own address worked.");
tox_self_get_address(tox2, address);
uint8_t message[TOX_MAX_FRIEND_REQUEST_LENGTH + 1];
ret = tox_friend_add(tox1, address, nullptr, 0, &error);
ck_assert_msg(ret == UINT32_MAX && error == TOX_ERR_FRIEND_ADD_NULL, "Sending request with no message worked.");
ret = tox_friend_add(tox1, address, message, 0, &error);
ck_assert_msg(ret == UINT32_MAX && error == TOX_ERR_FRIEND_ADD_NO_MESSAGE, "Sending request with no message worked.");
ret = tox_friend_add(tox1, address, message, sizeof(message), &error);
ck_assert_msg(ret == UINT32_MAX && error == TOX_ERR_FRIEND_ADD_TOO_LONG,
"TOX_MAX_FRIEND_REQUEST_LENGTH is too big.");
address[0]++;
ret = tox_friend_add(tox1, address, (const uint8_t *)"m", 1, &error);
ck_assert_msg(ret == UINT32_MAX && error == TOX_ERR_FRIEND_ADD_BAD_CHECKSUM,
"Adding address with bad checksum worked.");
tox_self_get_address(tox2, address);
ret = tox_friend_add(tox1, address, message, TOX_MAX_FRIEND_REQUEST_LENGTH, &error);
ck_assert_msg(ret == 0 && error == TOX_ERR_FRIEND_ADD_OK, "Failed to add friend.");
ret = tox_friend_add(tox1, address, message, TOX_MAX_FRIEND_REQUEST_LENGTH, &error);
ck_assert_msg(ret == UINT32_MAX && error == TOX_ERR_FRIEND_ADD_ALREADY_SENT, "Adding friend twice worked.");
tox_self_set_name(tox1, name, sizeof(name), nullptr);
ck_assert_msg(tox_self_get_name_size(tox1) == sizeof(name), "Can't set name of TOX_MAX_NAME_LENGTH");
tox_self_set_status_message(tox1, status_message, sizeof(status_message), nullptr);
ck_assert_msg(tox_self_get_status_message_size(tox1) == sizeof(status_message),
"Can't set status message of TOX_MAX_STATUS_MESSAGE_LENGTH");
tox_self_get_address(tox1, address);
size_t save_size = tox_get_savedata_size(tox1);
VLA(uint8_t, data, save_size);
tox_get_savedata(tox1, data);
tox_kill(tox2);
Tox_Err_New err_n;
struct Tox_Options *options = tox_options_new(nullptr);
tox_options_set_savedata_type(options, TOX_SAVEDATA_TYPE_TOX_SAVE);
tox_options_set_savedata_data(options, data, save_size);
tox2 = tox_new_log(options, &err_n, &index[1]);
ck_assert_msg(err_n == TOX_ERR_NEW_OK, "Load failed");
ck_assert_msg(tox_self_get_name_size(tox2) == sizeof name, "Wrong name size.");
ck_assert_msg(tox_self_get_status_message_size(tox2) == sizeof status_message, "Wrong status message size");
uint8_t name_loaded[TOX_MAX_NAME_LENGTH] = { 0 };
tox_self_get_name(tox2, name_loaded);
ck_assert_msg(!memcmp(name, name_loaded, sizeof name), "Wrong name.");
uint8_t status_message_loaded[TOX_MAX_STATUS_MESSAGE_LENGTH] = { 0 };
tox_self_get_status_message(tox2, status_message_loaded);
ck_assert_msg(!memcmp(status_message, status_message_loaded, sizeof status_message_loaded), "Wrong status message.");
uint8_t address2[TOX_ADDRESS_SIZE] = { 0 };
tox_self_get_address(tox2, address2);
ck_assert_msg(memcmp(address2, address, TOX_ADDRESS_SIZE) == 0, "Wrong address.");
uint8_t new_name[TOX_MAX_NAME_LENGTH] = { 0 };
tox_self_get_name(tox2, new_name);
ck_assert_msg(memcmp(name, new_name, TOX_MAX_NAME_LENGTH) == 0, "Wrong name");
uint8_t sk[TOX_SECRET_KEY_SIZE];
tox_self_get_secret_key(tox2, sk);
tox_kill(tox2);
tox_options_default(options);
tox_options_set_savedata_type(options, TOX_SAVEDATA_TYPE_SECRET_KEY);
tox_options_set_savedata_data(options, sk, sizeof(sk));
tox2 = tox_new_log(options, &err_n, &index[1]);
ck_assert_msg(err_n == TOX_ERR_NEW_OK, "Load failed");
uint8_t address3[TOX_ADDRESS_SIZE];
tox_self_get_address(tox2, address3);
ck_assert_msg(memcmp(address3, address, TOX_PUBLIC_KEY_SIZE) == 0, "Wrong public key.");
uint8_t pk[TOX_PUBLIC_KEY_SIZE];
tox_self_get_public_key(tox2, pk);
ck_assert_msg(memcmp(pk, address, TOX_PUBLIC_KEY_SIZE) == 0, "Wrong public key.");
tox_options_free(options);
tox_kill(tox1);
tox_kill(tox2);
}
int main(void)
{
setvbuf(stdout, nullptr, _IONBF, 0);
Tox *const tox1 = tox_new_log(nullptr, nullptr, nullptr);
Tox *const tox2 = tox_new_log(nullptr, nullptr, nullptr);
printf("bootstrapping tox2 off tox1\n");
uint8_t dht_key[TOX_PUBLIC_KEY_SIZE];
tox_self_get_dht_id(tox1, dht_key);
const uint16_t dht_port = tox_self_get_udp_port(tox1, nullptr);
tox_bootstrap(tox2, "localhost", dht_port, dht_key, nullptr);
struct test_data to_compare = {{0}};
uint8_t public_key[TOX_PUBLIC_KEY_SIZE];
tox_self_get_public_key(tox1, public_key);
tox_friend_add_norequest(tox2, public_key, nullptr);
tox_self_get_public_key(tox2, public_key);
tox_friend_add_norequest(tox1, public_key, nullptr);
uint8_t reference_name[TOX_MAX_NAME_LENGTH] = { 0 };
uint8_t reference_status[TOX_MAX_STATUS_MESSAGE_LENGTH] = { 0 };
set_random(tox1, tox_self_set_name, TOX_MAX_NAME_LENGTH);
set_random(tox2, tox_self_set_name, TOX_MAX_NAME_LENGTH);
set_random(tox1, tox_self_set_status_message, TOX_MAX_STATUS_MESSAGE_LENGTH);
set_random(tox2, tox_self_set_status_message, TOX_MAX_STATUS_MESSAGE_LENGTH);
tox_self_get_name(tox2, reference_name);
tox_self_get_status_message(tox2, reference_status);
tox_callback_friend_name(tox1, namechange_callback);
tox_callback_friend_status_message(tox1, statuschange_callback);
while (true) {
if (tox_self_get_connection_status(tox1) &&
tox_self_get_connection_status(tox2) &&
tox_friend_get_connection_status(tox1, 0, nullptr) == TOX_CONNECTION_UDP) {
printf("Connected.\n");
break;
}
tox_iterate(tox1, &to_compare);
tox_iterate(tox2, nullptr);
c_sleep(tox_iteration_interval(tox1));
}
while (true) {
if (to_compare.received_name && to_compare.received_status_message) {
printf("Exchanged names and status messages.\n");
break;
}
tox_iterate(tox1, &to_compare);
tox_iterate(tox2, nullptr);
c_sleep(tox_iteration_interval(tox1));
}
size_t save_size = tox_get_savedata_size(tox1);
VLA(uint8_t, savedata, save_size);
tox_get_savedata(tox1, savedata);
struct Tox_Options *const options = tox_options_new(nullptr);
tox_options_set_savedata_type(options, TOX_SAVEDATA_TYPE_TOX_SAVE);
tox_options_set_savedata_data(options, savedata, save_size);
Tox *const tox_to_compare = tox_new_log(options, nullptr, nullptr);
tox_friend_get_name(tox_to_compare, 0, to_compare.name, nullptr);
tox_friend_get_status_message(tox_to_compare, 0, to_compare.status_message, nullptr);
ck_assert_msg(memcmp(reference_name, to_compare.name, TOX_MAX_NAME_LENGTH) == 0,
"incorrect name: should be all zeroes");
ck_assert_msg(memcmp(reference_status, to_compare.status_message, TOX_MAX_STATUS_MESSAGE_LENGTH) == 0,
"incorrect status message: should be all zeroes");
tox_options_free(options);
tox_kill(tox1);
tox_kill(tox2);
tox_kill(tox_to_compare);
return 0;
}
bool CToxProto::InitToxCore()
{
debugLogA(__FUNCTION__": initializing tox core");
TOX_ERR_OPTIONS_NEW error;
Tox_Options *options = tox_options_new(&error);
if (error != TOX_ERR_OPTIONS_NEW_OK)
{
debugLogA(__FUNCTION__": failed to initialize tox options (%d)", error);
return false;
}
options->udp_enabled = getBool("EnableUDP", 1);
options->ipv6_enabled = getBool("EnableIPv6", 0);
if (hNetlib != NULL)
{
NETLIBUSERSETTINGS nlus = { sizeof(NETLIBUSERSETTINGS) };
CallService(MS_NETLIB_GETUSERSETTINGS, (WPARAM)hNetlib, (LPARAM)&nlus);
if (nlus.useProxy)
{
if (nlus.proxyType == PROXYTYPE_HTTP || nlus.proxyType == PROXYTYPE_HTTPS)
{
debugLogA("CToxProto::InitToxCore: setting http user proxy config");
options->proxy_type = TOX_PROXY_TYPE_HTTP;
mir_strcpy((char*)&options->proxy_host[0], nlus.szProxyServer);
options->proxy_port = nlus.wProxyPort;
}
if (nlus.proxyType == PROXYTYPE_SOCKS4 || nlus.proxyType == PROXYTYPE_SOCKS5)
{
debugLogA("CToxProto::InitToxCore: setting socks user proxy config");
options->proxy_type = TOX_PROXY_TYPE_SOCKS5;
mir_strcpy((char*)&options->proxy_host[0], nlus.szProxyServer);
options->proxy_port = nlus.wProxyPort;
}
}
}
debugLogA(__FUNCTION__": loading tox profile");
if (LoadToxProfile(options))
{
tox_callback_friend_request(tox, OnFriendRequest, this);
tox_callback_friend_message(tox, OnFriendMessage, this);
tox_callback_friend_read_receipt(tox, OnReadReceipt, this);
tox_callback_friend_typing(tox, OnTypingChanged, this);
//
tox_callback_friend_name(tox, OnFriendNameChange, this);
tox_callback_friend_status_message(tox, OnStatusMessageChanged, this);
tox_callback_friend_status(tox, OnUserStatusChanged, this);
tox_callback_friend_connection_status(tox, OnConnectionStatusChanged, this);
// transfers
tox_callback_file_recv_control(tox, OnFileRequest, this);
tox_callback_file_recv(tox, OnFriendFile, this);
tox_callback_file_recv_chunk(tox, OnDataReceiving, this);
tox_callback_file_chunk_request(tox, OnFileSendData, this);
// group chats
//tox_callback_group_invite(tox, OnGroupChatInvite, this);
// a/v
/*toxAv = toxav_new(tox, TOX_MAX_CALLS);
toxav_register_audio_callback(toxAv, OnFriendAudio, this);
toxav_register_callstate_callback(toxAv, OnAvInvite, av_OnInvite, this);
toxav_register_callstate_callback(toxAv, OnAvStart, av_OnStart, this);
toxav_register_callstate_callback(toxAv, OnAvCancel, av_OnCancel, this);
toxav_register_callstate_callback(toxAv, OnAvReject, av_OnReject, this);
toxav_register_callstate_callback(toxAv, OnAvEnd, av_OnEnd, this);
toxav_register_callstate_callback(toxAv, OnAvCallTimeout, av_OnRequestTimeout, this);
toxav_register_callstate_callback(toxAv, OnAvPeerTimeout, av_OnPeerTimeout, this);*/
uint8_t data[TOX_ADDRESS_SIZE];
tox_self_get_address(tox, data);
ToxHexAddress address(data);
setString(TOX_SETTINGS_ID, address);
uint8_t nick[TOX_MAX_NAME_LENGTH] = { 0 };
tox_self_get_name(tox, nick);
setWString("Nick", ptrW(Utf8DecodeW((char*)nick)));
uint8_t statusMessage[TOX_MAX_STATUS_MESSAGE_LENGTH] = { 0 };
tox_self_get_status_message(tox, statusMessage);
setWString("StatusMsg", ptrW(Utf8DecodeW((char*)statusMessage)));
return true;
}
tox_options_free(options);
return false;
}
int main(int argc, char *argv[])
{
Tox *tox1 = tox_new_log(0, 0, 0);
Tox *tox2 = tox_new_log(0, 0, 0);
struct test_data to_compare = { { 0 } };
uint8_t public_key[TOX_PUBLIC_KEY_SIZE];
tox_self_get_public_key(tox1, public_key);
tox_friend_add_norequest(tox2, public_key, NULL);
tox_self_get_public_key(tox2, public_key);
tox_friend_add_norequest(tox1, public_key, NULL);
uint8_t reference_name[TOX_MAX_NAME_LENGTH] = { 0 };
uint8_t reference_status[TOX_MAX_STATUS_MESSAGE_LENGTH] = { 0 };
set_random(tox1, tox_self_set_name, TOX_MAX_NAME_LENGTH);
set_random(tox2, tox_self_set_name, TOX_MAX_NAME_LENGTH);
set_random(tox1, tox_self_set_status_message, TOX_MAX_STATUS_MESSAGE_LENGTH);
set_random(tox2, tox_self_set_status_message, TOX_MAX_STATUS_MESSAGE_LENGTH);
tox_self_get_name(tox2, reference_name);
tox_self_get_status_message(tox2, reference_status);
tox_callback_friend_name(tox1, namechange_callback);
tox_callback_friend_status_message(tox1, statuschange_callback);
while (true) {
if (tox_self_get_connection_status(tox1) &&
tox_self_get_connection_status(tox2) &&
tox_friend_get_connection_status(tox1, 0, 0) == TOX_CONNECTION_UDP) {
printf("Connected.\n");
break;
}
tox_iterate(tox1, &to_compare);
tox_iterate(tox2, NULL);
c_sleep(tox_iteration_interval(tox1));
}
while (true) {
if (to_compare.received_name && to_compare.received_status_message) {
printf("Exchanged names and status messages.\n");
break;
}
tox_iterate(tox1, &to_compare);
tox_iterate(tox2, NULL);
c_sleep(tox_iteration_interval(tox1));
}
size_t save_size = tox_get_savedata_size(tox1);
VLA(uint8_t, savedata, save_size);
tox_get_savedata(tox1, savedata);
struct Tox_Options *options = tox_options_new(NULL);
tox_options_set_savedata_type(options, TOX_SAVEDATA_TYPE_TOX_SAVE);
tox_options_set_savedata_data(options, savedata, save_size);
Tox *tox_to_compare = tox_new(options, 0);
tox_friend_get_name(tox_to_compare, 0, to_compare.name, 0);
tox_friend_get_status_message(tox_to_compare, 0, to_compare.status_message, 0);
assert(memcmp(reference_name, to_compare.name, TOX_MAX_NAME_LENGTH) == 0);
assert(memcmp(reference_status, to_compare.status_message, TOX_MAX_STATUS_MESSAGE_LENGTH) == 0);
tox_options_free(options);
tox_kill(tox1);
tox_kill(tox2);
tox_kill(tox_to_compare);
return 0;
}
static void prompt_onDraw(ToxWindow *self, Tox *m)
{
int x2, y2;
getmaxyx(self->window, y2, x2);
ChatContext *ctx = self->chatwin;
pthread_mutex_lock(&Winthread.lock);
line_info_print(self);
pthread_mutex_unlock(&Winthread.lock);
wclear(ctx->linewin);
curs_set(1);
if (ctx->len > 0)
mvwprintw(ctx->linewin, 1, 0, "%ls", &ctx->line[ctx->start]);
StatusBar *statusbar = self->stb;
mvwhline(statusbar->topline, 1, 0, ACS_HLINE, x2);
wmove(statusbar->topline, 0, 0);
pthread_mutex_lock(&Winthread.lock);
TOX_CONNECTION connection = statusbar->connection;
pthread_mutex_unlock(&Winthread.lock);
if (connection != TOX_CONNECTION_NONE) {
int colour = MAGENTA;
const char *status_text = "ERROR";
pthread_mutex_lock(&Winthread.lock);
TOX_USER_STATUS status = statusbar->status;
pthread_mutex_unlock(&Winthread.lock);
switch (status) {
case TOX_USER_STATUS_NONE:
status_text = "Online";
colour = GREEN;
break;
case TOX_USER_STATUS_AWAY:
status_text = "Away";
colour = YELLOW;
break;
case TOX_USER_STATUS_BUSY:
status_text = "Busy";
colour = RED;
break;
}
wattron(statusbar->topline, COLOR_PAIR(colour) | A_BOLD);
wprintw(statusbar->topline, " [%s]", status_text);
wattroff(statusbar->topline, COLOR_PAIR(colour) | A_BOLD);
wattron(statusbar->topline, A_BOLD);
pthread_mutex_lock(&Winthread.lock);
wprintw(statusbar->topline, " %s", statusbar->nick);
pthread_mutex_unlock(&Winthread.lock);
wattroff(statusbar->topline, A_BOLD);
} else {
wprintw(statusbar->topline, " [Offline]");
wattron(statusbar->topline, A_BOLD);
pthread_mutex_lock(&Winthread.lock);
wprintw(statusbar->topline, " %s", statusbar->nick);
pthread_mutex_unlock(&Winthread.lock);
wattroff(statusbar->topline, A_BOLD);
}
/* Reset statusbar->statusmsg on window resize */
if (x2 != self->x) {
char statusmsg[TOX_MAX_STATUS_MESSAGE_LENGTH];
pthread_mutex_lock(&Winthread.lock);
size_t slen = tox_self_get_status_message_size(m);
tox_self_get_status_message (m, (uint8_t*) statusmsg);
statusmsg[slen] = '\0';
snprintf(statusbar->statusmsg, sizeof(statusbar->statusmsg), "%s", statusmsg);
statusbar->statusmsg_len = strlen(statusbar->statusmsg);
pthread_mutex_unlock(&Winthread.lock);
}
self->x = x2;
/* Truncate note if it doesn't fit in statusbar */
uint16_t maxlen = x2 - getcurx(statusbar->topline) - 3;
pthread_mutex_lock(&Winthread.lock);
if (statusbar->statusmsg_len > maxlen) {
statusbar->statusmsg[maxlen - 3] = '\0';
strcat(statusbar->statusmsg, "...");
statusbar->statusmsg_len = maxlen;
}
if (statusbar->statusmsg[0])
wprintw(statusbar->topline, " : %s", statusbar->statusmsg);
pthread_mutex_unlock(&Winthread.lock);
mvwhline(self->window, y2 - CHATBOX_HEIGHT, 0, ACS_HLINE, x2);
int y, x;
getyx(self->window, y, x);
(void) x;
int new_x = ctx->start ? x2 - 1 : MAX(0, wcswidth(ctx->line, ctx->pos));
wmove(self->window, y + 1, new_x);
wrefresh(self->window);
if (self->help->active)
help_onDraw(self);
}
