mirror of
https://github.com/Tha14/toxic.git
synced 2024-11-21 21:33:03 +01:00
Update astylerc to match toxcore & reformat all source files
This commit is contained in:
parent
cb524dcbc3
commit
a37bf300f9
35
astylerc
35
astylerc
@ -1,11 +1,26 @@
|
||||
# Bracket Style Options
|
||||
--style=kr
|
||||
--pad-header
|
||||
--max-code-length=120
|
||||
--convert-tabs
|
||||
--indent-switches
|
||||
--pad-oper
|
||||
--align-pointer=name
|
||||
--align-reference=name
|
||||
--preserve-date
|
||||
--lineend=linux
|
||||
--break-blocks
|
||||
|
||||
# Tab Options
|
||||
--indent=spaces=4
|
||||
|
||||
# Indentation Options
|
||||
--indent-switches
|
||||
|
||||
# Padding Options
|
||||
--pad-header
|
||||
--break-blocks
|
||||
--pad-oper
|
||||
--unpad-paren
|
||||
--align-pointer=name
|
||||
--align-reference=name
|
||||
|
||||
# Formatting Options
|
||||
--add-brackets
|
||||
--convert-tabs
|
||||
--max-code-length=120
|
||||
|
||||
# Other Options
|
||||
--preserve-date
|
||||
--formatted
|
||||
--lineend=linux
|
||||
|
29
src/api.c
29
src/api.c
@ -46,8 +46,9 @@ extern struct user_settings *user_settings;
|
||||
|
||||
void api_display(const char *const msg)
|
||||
{
|
||||
if (msg == NULL)
|
||||
if (msg == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
self_window = get_active_window();
|
||||
line_info_add(self_window, NULL, NULL, NULL, SYS_MSG, 0, 0, msg);
|
||||
@ -63,8 +64,9 @@ char *api_get_nick(void)
|
||||
size_t len = tox_self_get_name_size(user_tox);
|
||||
uint8_t *name = malloc(len + 1);
|
||||
|
||||
if (name == NULL)
|
||||
if (name == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
tox_self_get_name(user_tox, name);
|
||||
name[len] = '\0';
|
||||
@ -81,8 +83,9 @@ 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)
|
||||
if (status == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
tox_self_get_status_message(user_tox, status);
|
||||
status[len] = '\0';
|
||||
@ -91,14 +94,16 @@ char *api_get_status_message(void)
|
||||
|
||||
void api_send(const char *msg)
|
||||
{
|
||||
if (msg == NULL || self_window->chatwin->cqueue == NULL)
|
||||
if (msg == NULL || self_window->chatwin->cqueue == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
char *name = api_get_nick();
|
||||
char timefrmt[TIME_STR_SIZE];
|
||||
|
||||
if (name == NULL)
|
||||
if (name == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
self_window = get_active_window();
|
||||
get_time_str(timefrmt, sizeof(timefrmt));
|
||||
@ -144,9 +149,12 @@ void cmd_run(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX
|
||||
cur_window = window;
|
||||
self_window = self;
|
||||
|
||||
if ( argc != 1 ) {
|
||||
if ( argc < 1 ) error_str = "Path must be specified!";
|
||||
else error_str = "Only one argument allowed!";
|
||||
if (argc != 1) {
|
||||
if (argc < 1) {
|
||||
error_str = "Path must be specified!";
|
||||
} else {
|
||||
error_str = "Only one argument allowed!";
|
||||
}
|
||||
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, error_str);
|
||||
return;
|
||||
@ -154,7 +162,7 @@ void cmd_run(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX
|
||||
|
||||
fp = fopen(argv[1], "r");
|
||||
|
||||
if ( fp == NULL ) {
|
||||
if (fp == NULL) {
|
||||
error_str = "Path does not exist!";
|
||||
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, error_str);
|
||||
@ -173,8 +181,9 @@ void invoke_autoruns(WINDOW *window, ToxWindow *self)
|
||||
DIR *d;
|
||||
FILE *fp;
|
||||
|
||||
if (user_settings->autorun_path[0] == '\0')
|
||||
if (user_settings->autorun_path[0] == '\0') {
|
||||
return;
|
||||
}
|
||||
|
||||
d = opendir(user_settings->autorun_path);
|
||||
|
||||
|
320
src/audio_call.c
320
src/audio_call.c
@ -73,44 +73,46 @@ static int set_call(Call *call, bool start)
|
||||
call->vout_idx = -1;
|
||||
#endif /* VIDEO */
|
||||
|
||||
if ( start ) {
|
||||
if (start) {
|
||||
call->ttas = true;
|
||||
|
||||
if ( pthread_mutex_init(&call->mutex, NULL) != 0 )
|
||||
if (pthread_mutex_init(&call->mutex, NULL) != 0) {
|
||||
return -1;
|
||||
}
|
||||
} else {
|
||||
call->ttid = 0;
|
||||
|
||||
if ( pthread_mutex_destroy(&call->mutex) != 0 )
|
||||
if (pthread_mutex_destroy(&call->mutex) != 0) {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void call_cb ( ToxAV *av, uint32_t friend_number, bool audio_enabled, bool video_enabled,
|
||||
void *user_data );
|
||||
void callstate_cb ( ToxAV *av, uint32_t friend_number, uint32_t state, void *user_data );
|
||||
void receive_audio_frame_cb ( ToxAV *av, uint32_t friend_number, int16_t const *pcm, size_t sample_count,
|
||||
uint8_t channels, uint32_t sampling_rate, void *user_data );
|
||||
void receive_video_frame_cb ( ToxAV *av, uint32_t friend_number,
|
||||
uint16_t width, uint16_t height,
|
||||
uint8_t const *y, uint8_t const *u, uint8_t const *v, uint8_t const *a,
|
||||
int32_t ystride, int32_t ustride, int32_t vstride, int32_t astride, void *user_data );
|
||||
void call_cb(ToxAV *av, uint32_t friend_number, bool audio_enabled, bool video_enabled,
|
||||
void *user_data);
|
||||
void callstate_cb(ToxAV *av, uint32_t friend_number, uint32_t state, void *user_data);
|
||||
void receive_audio_frame_cb(ToxAV *av, uint32_t friend_number, int16_t const *pcm, size_t sample_count,
|
||||
uint8_t channels, uint32_t sampling_rate, void *user_data);
|
||||
void receive_video_frame_cb(ToxAV *av, uint32_t friend_number,
|
||||
uint16_t width, uint16_t height,
|
||||
uint8_t const *y, uint8_t const *u, uint8_t const *v, uint8_t const *a,
|
||||
int32_t ystride, int32_t ustride, int32_t vstride, int32_t astride, void *user_data);
|
||||
|
||||
void callback_recv_invite ( Tox *m, uint32_t friend_number );
|
||||
void callback_recv_ringing ( uint32_t friend_number );
|
||||
void callback_recv_starting ( uint32_t friend_number );
|
||||
void callback_recv_ending ( uint32_t friend_number );
|
||||
void callback_call_started ( uint32_t friend_number );
|
||||
void callback_call_canceled ( uint32_t friend_number );
|
||||
void callback_call_rejected ( uint32_t friend_number );
|
||||
void callback_call_ended ( uint32_t friend_number );
|
||||
void callback_recv_invite(Tox *m, uint32_t friend_number);
|
||||
void callback_recv_ringing(uint32_t friend_number);
|
||||
void callback_recv_starting(uint32_t friend_number);
|
||||
void callback_recv_ending(uint32_t friend_number);
|
||||
void callback_call_started(uint32_t friend_number);
|
||||
void callback_call_canceled(uint32_t friend_number);
|
||||
void callback_call_rejected(uint32_t friend_number);
|
||||
void callback_call_ended(uint32_t friend_number);
|
||||
|
||||
void write_device_callback( uint32_t friend_number, const int16_t *PCM, uint16_t sample_count, uint8_t channels,
|
||||
uint32_t sample_rate );
|
||||
void write_device_callback(uint32_t friend_number, const int16_t *PCM, uint16_t sample_count, uint8_t channels,
|
||||
uint32_t sample_rate);
|
||||
|
||||
static void print_err (ToxWindow *self, const char *error_str)
|
||||
static void print_err(ToxWindow *self, const char *error_str)
|
||||
{
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%s", error_str);
|
||||
}
|
||||
@ -136,14 +138,14 @@ ToxAV *init_audio(ToxWindow *self, Tox *tox)
|
||||
CallControl.video_frame_duration = 0;
|
||||
#endif /* VIDEO */
|
||||
|
||||
if ( !CallControl.av ) {
|
||||
if (!CallControl.av) {
|
||||
CallControl.audio_errors |= ae_StartingCoreAudio;
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to init ToxAV");
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if ( init_devices(CallControl.av) == de_InternalError ) {
|
||||
if (init_devices(CallControl.av) == de_InternalError) {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to init devices");
|
||||
toxav_kill(CallControl.av);
|
||||
|
||||
@ -161,11 +163,13 @@ void terminate_audio()
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < CallControl.max_calls; ++i)
|
||||
for (i = 0; i < CallControl.max_calls; ++i) {
|
||||
stop_transmission(&CallControl.calls[i], i);
|
||||
}
|
||||
|
||||
if ( CallControl.av )
|
||||
if (CallControl.av) {
|
||||
toxav_kill(CallControl.av);
|
||||
}
|
||||
|
||||
terminate_devices();
|
||||
}
|
||||
@ -177,48 +181,54 @@ void read_device_callback(const int16_t *captured, uint32_t size, void *data)
|
||||
int64_t sample_count = ((int64_t) CallControl.audio_sample_rate) * \
|
||||
((int64_t) CallControl.audio_frame_duration) / 1000;
|
||||
|
||||
if ( sample_count <= 0 || toxav_audio_send_frame(CallControl.av, friend_number,
|
||||
if (sample_count <= 0 || toxav_audio_send_frame(CallControl.av, friend_number,
|
||||
captured, sample_count,
|
||||
CallControl.audio_channels,
|
||||
CallControl.audio_sample_rate, &error) == false ) {
|
||||
CallControl.audio_sample_rate, &error) == false) {
|
||||
}
|
||||
}
|
||||
|
||||
void write_device_callback(uint32_t friend_number, const int16_t *PCM, uint16_t sample_count, uint8_t channels,
|
||||
uint32_t sample_rate)
|
||||
{
|
||||
if ( CallControl.calls[friend_number].ttas )
|
||||
if (CallControl.calls[friend_number].ttas) {
|
||||
write_out(CallControl.calls[friend_number].out_idx, PCM, sample_count, channels, sample_rate);
|
||||
}
|
||||
}
|
||||
|
||||
int start_transmission(ToxWindow *self, Call *call)
|
||||
{
|
||||
if ( !self || !CallControl.av ) {
|
||||
if (!self || !CallControl.av) {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to prepare transmission");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (set_call(call, true) == -1)
|
||||
if (set_call(call, true) == -1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
DeviceError error = open_primary_device(input, &call->in_idx,
|
||||
CallControl.audio_sample_rate, CallControl.audio_frame_duration, CallControl.audio_channels);
|
||||
|
||||
if ( error != de_None ) {
|
||||
if ( error == de_FailedStart)
|
||||
if (error != de_None) {
|
||||
if (error == de_FailedStart) {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to start input device");
|
||||
}
|
||||
|
||||
if ( error == de_InternalError )
|
||||
if (error == de_InternalError) {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Internal error with opening input device");
|
||||
}
|
||||
}
|
||||
|
||||
if ( register_device_callback(self->num, call->in_idx,
|
||||
read_device_callback, &self->num, true) != de_None)
|
||||
if (register_device_callback(self->num, call->in_idx,
|
||||
read_device_callback, &self->num, true) != de_None)
|
||||
/* Set VAD as true for all; TODO: Make it more dynamic */
|
||||
{
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to register input handler!");
|
||||
}
|
||||
|
||||
if ( open_primary_device(output, &call->out_idx,
|
||||
CallControl.audio_sample_rate, CallControl.audio_frame_duration, CallControl.audio_channels) != de_None ) {
|
||||
if (open_primary_device(output, &call->out_idx,
|
||||
CallControl.audio_sample_rate, CallControl.audio_frame_duration, CallControl.audio_channels) != de_None) {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to open output device!");
|
||||
call->has_output = 0;
|
||||
}
|
||||
@ -228,23 +238,27 @@ int start_transmission(ToxWindow *self, Call *call)
|
||||
|
||||
int stop_transmission(Call *call, uint32_t friend_number)
|
||||
{
|
||||
if ( call->ttas ) {
|
||||
if (call->ttas) {
|
||||
TOXAV_ERR_CALL_CONTROL error = TOXAV_ERR_CALL_CONTROL_OK;
|
||||
|
||||
if ( CallControl.call_state > TOXAV_FRIEND_CALL_STATE_FINISHED )
|
||||
if (CallControl.call_state > TOXAV_FRIEND_CALL_STATE_FINISHED) {
|
||||
toxav_call_control(CallControl.av, friend_number, TOXAV_CALL_CONTROL_CANCEL, &error);
|
||||
}
|
||||
|
||||
if ( error == TOXAV_ERR_CALL_CONTROL_OK ) {
|
||||
if (error == TOXAV_ERR_CALL_CONTROL_OK) {
|
||||
call->ttas = false;
|
||||
|
||||
if ( call->in_idx != -1 )
|
||||
if (call->in_idx != -1) {
|
||||
close_device(input, call->in_idx);
|
||||
}
|
||||
|
||||
if ( call->out_idx != -1 )
|
||||
if (call->out_idx != -1) {
|
||||
close_device(output, call->out_idx);
|
||||
}
|
||||
|
||||
if ( set_call(call, false) == -1 )
|
||||
if (set_call(call, false) == -1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
} else {
|
||||
@ -277,8 +291,8 @@ void callstate_cb(ToxAV *av, uint32_t friend_number, uint32_t state, void *user_
|
||||
{
|
||||
CallControl.call_state = state;
|
||||
|
||||
switch ( state ) {
|
||||
case ( TOXAV_FRIEND_CALL_STATE_ERROR ):
|
||||
switch (state) {
|
||||
case (TOXAV_FRIEND_CALL_STATE_ERROR):
|
||||
line_info_add(CallControl.prompt, NULL, NULL, NULL, SYS_MSG, 0, 0, "ToxAV callstate error!");
|
||||
|
||||
#ifdef VIDEO
|
||||
@ -291,11 +305,12 @@ void callstate_cb(ToxAV *av, uint32_t friend_number, uint32_t state, void *user_
|
||||
|
||||
break;
|
||||
|
||||
case ( TOXAV_FRIEND_CALL_STATE_FINISHED ):
|
||||
if ( CallControl.pending_call )
|
||||
case (TOXAV_FRIEND_CALL_STATE_FINISHED):
|
||||
if (CallControl.pending_call) {
|
||||
callback_call_rejected(friend_number);
|
||||
else
|
||||
} else {
|
||||
callback_call_ended(friend_number);
|
||||
}
|
||||
|
||||
#ifdef VIDEO
|
||||
callback_recv_video_end(friend_number);
|
||||
@ -311,7 +326,7 @@ void callstate_cb(ToxAV *av, uint32_t friend_number, uint32_t state, void *user_
|
||||
break;
|
||||
|
||||
default:
|
||||
if ( CallControl.pending_call ) {
|
||||
if (CallControl.pending_call) {
|
||||
/* Start answered call */
|
||||
callback_call_started(friend_number);
|
||||
CallControl.pending_call = false;
|
||||
@ -320,10 +335,11 @@ void callstate_cb(ToxAV *av, uint32_t friend_number, uint32_t state, void *user_
|
||||
#ifdef VIDEO
|
||||
|
||||
/* Handle receiving client video call states */
|
||||
if ( state & TOXAV_FRIEND_CALL_STATE_SENDING_V )
|
||||
if (state & TOXAV_FRIEND_CALL_STATE_SENDING_V) {
|
||||
callback_recv_video_starting(friend_number);
|
||||
else if ( state & ~TOXAV_FRIEND_CALL_STATE_SENDING_V )
|
||||
} else if (state & ~TOXAV_FRIEND_CALL_STATE_SENDING_V) {
|
||||
callback_recv_video_end(friend_number);
|
||||
}
|
||||
|
||||
#endif /* VIDEO */
|
||||
}
|
||||
@ -347,12 +363,14 @@ void audio_bit_rate_status_cb(ToxAV *av, uint32_t friend_number, uint32_t audio_
|
||||
|
||||
void callback_recv_invite(Tox *m, uint32_t friend_number)
|
||||
{
|
||||
if (friend_number >= Friends.max_idx)
|
||||
if (friend_number >= Friends.max_idx) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (Friends.list[friend_number].chatwin == -1) {
|
||||
if (get_num_active_windows() >= MAX_WINDOWS_NUM)
|
||||
if (get_num_active_windows() >= MAX_WINDOWS_NUM) {
|
||||
return;
|
||||
}
|
||||
|
||||
Friends.list[friend_number].chatwin = add_window(m, new_chat(m, Friends.list[friend_number].num));
|
||||
}
|
||||
@ -384,11 +402,12 @@ void callback_recv_starting(uint32_t friend_number)
|
||||
int i;
|
||||
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
|
||||
if ( windows[i].onStarting != NULL && windows[i].num == friend_number ) {
|
||||
if (windows[i].onStarting != NULL && windows[i].num == friend_number) {
|
||||
windows[i].onStarting(&windows[i], CallControl.av, friend_number, CallControl.call_state);
|
||||
|
||||
if ( 0 != start_transmission(&windows[i], &CallControl.calls[friend_number]) ) /* YEAH! */
|
||||
if (0 != start_transmission(&windows[i], &CallControl.calls[friend_number])) { /* YEAH! */
|
||||
line_info_add(&windows[i], NULL, NULL, NULL, SYS_MSG, 0, 0, "Error starting transmission!");
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
@ -412,10 +431,10 @@ void callback_call_started(uint32_t friend_number)
|
||||
int i;
|
||||
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i)
|
||||
if ( windows[i].onStart != NULL && windows[i].num == friend_number ) {
|
||||
if (windows[i].onStart != NULL && windows[i].num == friend_number) {
|
||||
windows[i].onStart(&windows[i], CallControl.av, friend_number, CallControl.call_state);
|
||||
|
||||
if ( 0 != start_transmission(&windows[i], &CallControl.calls[friend_number]) ) {/* YEAH! */
|
||||
if (0 != start_transmission(&windows[i], &CallControl.calls[friend_number])) { /* YEAH! */
|
||||
line_info_add(&windows[i], NULL, NULL, NULL, SYS_MSG, 0, 0, "Error starting transmission!");
|
||||
return;
|
||||
}
|
||||
@ -468,34 +487,40 @@ void cmd_call(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MA
|
||||
TOXAV_ERR_CALL error;
|
||||
const char *error_str;
|
||||
|
||||
if ( argc != 0 ) {
|
||||
if (argc != 0) {
|
||||
error_str = "Unknown arguments.";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if ( !CallControl.av ) {
|
||||
if (!CallControl.av) {
|
||||
error_str = "ToxAV not supported!";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if ( !self->stb->connection ) {
|
||||
if (!self->stb->connection) {
|
||||
error_str = "Friend is offline.";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if ( CallControl.pending_call ) {
|
||||
if (CallControl.pending_call) {
|
||||
error_str = "Already a pending call!";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
toxav_call(CallControl.av, self->num, CallControl.audio_bit_rate, CallControl.video_bit_rate, &error);
|
||||
|
||||
if ( error != TOXAV_ERR_CALL_OK ) {
|
||||
if ( error == TOXAV_ERR_CALL_FRIEND_ALREADY_IN_CALL ) error_str = "Already in a call!";
|
||||
else if ( error == TOXAV_ERR_CALL_MALLOC ) error_str = "Memory allocation issue";
|
||||
else if ( error == TOXAV_ERR_CALL_FRIEND_NOT_FOUND ) error_str = "Friend number invalid";
|
||||
else if ( error == TOXAV_ERR_CALL_FRIEND_NOT_CONNECTED ) error_str = "Friend is valid but not currently connected";
|
||||
else error_str = "Internal error!";
|
||||
if (error != TOXAV_ERR_CALL_OK) {
|
||||
if (error == TOXAV_ERR_CALL_FRIEND_ALREADY_IN_CALL) {
|
||||
error_str = "Already in a call!";
|
||||
} else if (error == TOXAV_ERR_CALL_MALLOC) {
|
||||
error_str = "Memory allocation issue";
|
||||
} else if (error == TOXAV_ERR_CALL_FRIEND_NOT_FOUND) {
|
||||
error_str = "Friend number invalid";
|
||||
} else if (error == TOXAV_ERR_CALL_FRIEND_NOT_CONNECTED) {
|
||||
error_str = "Friend is valid but not currently connected";
|
||||
} else {
|
||||
error_str = "Internal error!";
|
||||
}
|
||||
|
||||
goto on_error;
|
||||
}
|
||||
@ -513,29 +538,35 @@ void cmd_answer(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
|
||||
TOXAV_ERR_ANSWER error;
|
||||
const char *error_str;
|
||||
|
||||
if ( argc != 0 ) {
|
||||
if (argc != 0) {
|
||||
error_str = "Unknown arguments.";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if ( !CallControl.av ) {
|
||||
if (!CallControl.av) {
|
||||
error_str = "Audio not supported!";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if ( !CallControl.pending_call ) {
|
||||
if (!CallControl.pending_call) {
|
||||
error_str = "No incoming call!";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
toxav_answer(CallControl.av, self->num, CallControl.audio_bit_rate, CallControl.video_bit_rate, &error);
|
||||
|
||||
if ( error != TOXAV_ERR_ANSWER_OK ) {
|
||||
if ( error == TOXAV_ERR_ANSWER_FRIEND_NOT_CALLING ) error_str = "No incoming call!";
|
||||
else if ( error == TOXAV_ERR_ANSWER_CODEC_INITIALIZATION ) error_str = "Failed to initialize codecs!";
|
||||
else if ( error == TOXAV_ERR_ANSWER_FRIEND_NOT_FOUND ) error_str = "Friend not found!";
|
||||
else if ( error == TOXAV_ERR_ANSWER_INVALID_BIT_RATE ) error_str = "Invalid bit rate!";
|
||||
else error_str = "Internal error!";
|
||||
if (error != TOXAV_ERR_ANSWER_OK) {
|
||||
if (error == TOXAV_ERR_ANSWER_FRIEND_NOT_CALLING) {
|
||||
error_str = "No incoming call!";
|
||||
} else if (error == TOXAV_ERR_ANSWER_CODEC_INITIALIZATION) {
|
||||
error_str = "Failed to initialize codecs!";
|
||||
} else if (error == TOXAV_ERR_ANSWER_FRIEND_NOT_FOUND) {
|
||||
error_str = "Friend not found!";
|
||||
} else if (error == TOXAV_ERR_ANSWER_INVALID_BIT_RATE) {
|
||||
error_str = "Invalid bit rate!";
|
||||
} else {
|
||||
error_str = "Internal error!";
|
||||
}
|
||||
|
||||
goto on_error;
|
||||
}
|
||||
@ -546,24 +577,24 @@ void cmd_answer(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
|
||||
|
||||
return;
|
||||
on_error:
|
||||
print_err (self, error_str);
|
||||
print_err(self, error_str);
|
||||
}
|
||||
|
||||
void cmd_reject(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
|
||||
{
|
||||
const char *error_str;
|
||||
|
||||
if ( argc != 0 ) {
|
||||
if (argc != 0) {
|
||||
error_str = "Unknown arguments.";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if ( !CallControl.av ) {
|
||||
if (!CallControl.av) {
|
||||
error_str = "Audio not supported!";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if ( !CallControl.pending_call ) {
|
||||
if (!CallControl.pending_call) {
|
||||
error_str = "No incoming call!";
|
||||
goto on_error;
|
||||
}
|
||||
@ -577,24 +608,24 @@ void cmd_reject(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
|
||||
|
||||
return;
|
||||
on_error:
|
||||
print_err (self, error_str);
|
||||
print_err(self, error_str);
|
||||
}
|
||||
|
||||
void cmd_hangup(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
|
||||
{
|
||||
const char *error_str = NULL;
|
||||
|
||||
if ( !CallControl.av ) {
|
||||
if (!CallControl.av) {
|
||||
error_str = "Audio not supported!";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if ( argc != 0 ) {
|
||||
if (argc != 0) {
|
||||
error_str = "Unknown arguments.";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if ( !self->is_call && !CallControl.pending_call ) {
|
||||
if (!self->is_call && !CallControl.pending_call) {
|
||||
error_str = "Not in a call.";
|
||||
goto on_error;
|
||||
}
|
||||
@ -606,27 +637,32 @@ void cmd_hangup(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
|
||||
stop_current_call(self);
|
||||
return;
|
||||
on_error:
|
||||
print_err (self, error_str);
|
||||
print_err(self, error_str);
|
||||
}
|
||||
|
||||
void cmd_list_devices(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
|
||||
{
|
||||
const char *error_str;
|
||||
|
||||
if ( argc != 1 ) {
|
||||
if ( argc < 1 ) error_str = "Type must be specified!";
|
||||
else error_str = "Only one argument allowed!";
|
||||
if (argc != 1) {
|
||||
if (argc < 1) {
|
||||
error_str = "Type must be specified!";
|
||||
} else {
|
||||
error_str = "Only one argument allowed!";
|
||||
}
|
||||
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
DeviceType type;
|
||||
|
||||
if ( strcasecmp(argv[1], "in") == 0 ) /* Input devices */
|
||||
if (strcasecmp(argv[1], "in") == 0) { /* Input devices */
|
||||
type = input;
|
||||
}
|
||||
|
||||
else if ( strcasecmp(argv[1], "out") == 0 ) /* Output devices */
|
||||
else if (strcasecmp(argv[1], "out") == 0) { /* Output devices */
|
||||
type = output;
|
||||
}
|
||||
|
||||
else {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid type: %s", argv[1]);
|
||||
@ -640,7 +676,7 @@ void cmd_list_devices(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*
|
||||
|
||||
return;
|
||||
on_error:
|
||||
print_err (self, error_str);
|
||||
print_err(self, error_str);
|
||||
}
|
||||
|
||||
/* This changes primary device only */
|
||||
@ -648,21 +684,27 @@ void cmd_change_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (
|
||||
{
|
||||
const char *error_str;
|
||||
|
||||
if ( argc != 2 ) {
|
||||
if ( argc < 1 ) error_str = "Type must be specified!";
|
||||
else if ( argc < 2 ) error_str = "Must have id!";
|
||||
else error_str = "Only two arguments allowed!";
|
||||
if (argc != 2) {
|
||||
if (argc < 1) {
|
||||
error_str = "Type must be specified!";
|
||||
} else if (argc < 2) {
|
||||
error_str = "Must have id!";
|
||||
} else {
|
||||
error_str = "Only two arguments allowed!";
|
||||
}
|
||||
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
DeviceType type;
|
||||
|
||||
if ( strcmp(argv[1], "in") == 0 ) /* Input devices */
|
||||
if (strcmp(argv[1], "in") == 0) { /* Input devices */
|
||||
type = input;
|
||||
}
|
||||
|
||||
else if ( strcmp(argv[1], "out") == 0 ) /* Output devices */
|
||||
else if (strcmp(argv[1], "out") == 0) { /* Output devices */
|
||||
type = output;
|
||||
}
|
||||
|
||||
else {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid type: %s", argv[1]);
|
||||
@ -673,40 +715,46 @@ void cmd_change_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (
|
||||
char *end;
|
||||
long int selection = strtol(argv[2], &end, 10);
|
||||
|
||||
if ( *end ) {
|
||||
if (*end) {
|
||||
error_str = "Invalid input";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if ( set_primary_device(type, selection) == de_InvalidSelection ) {
|
||||
if (set_primary_device(type, selection) == de_InvalidSelection) {
|
||||
error_str = "Invalid selection!";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
return;
|
||||
on_error:
|
||||
print_err (self, error_str);
|
||||
print_err(self, error_str);
|
||||
}
|
||||
|
||||
void cmd_ccur_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
|
||||
{
|
||||
const char *error_str;
|
||||
|
||||
if ( argc != 2 ) {
|
||||
if ( argc < 1 ) error_str = "Type must be specified!";
|
||||
else if ( argc < 2 ) error_str = "Must have id!";
|
||||
else error_str = "Only two arguments allowed!";
|
||||
if (argc != 2) {
|
||||
if (argc < 1) {
|
||||
error_str = "Type must be specified!";
|
||||
} else if (argc < 2) {
|
||||
error_str = "Must have id!";
|
||||
} else {
|
||||
error_str = "Only two arguments allowed!";
|
||||
}
|
||||
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
DeviceType type;
|
||||
|
||||
if ( strcmp(argv[1], "in") == 0 ) /* Input devices */
|
||||
if (strcmp(argv[1], "in") == 0) { /* Input devices */
|
||||
type = input;
|
||||
}
|
||||
|
||||
else if ( strcmp(argv[1], "out") == 0 ) /* Output devices */
|
||||
else if (strcmp(argv[1], "out") == 0) { /* Output devices */
|
||||
type = output;
|
||||
}
|
||||
|
||||
else {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid type: %s", argv[1]);
|
||||
@ -717,24 +765,24 @@ void cmd_ccur_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*a
|
||||
char *end;
|
||||
long int selection = strtol(argv[2], &end, 10);
|
||||
|
||||
if ( *end ) {
|
||||
if (*end) {
|
||||
error_str = "Invalid input";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if ( selection_valid(type, selection) == de_InvalidSelection ) {
|
||||
if (selection_valid(type, selection) == de_InvalidSelection) {
|
||||
error_str = "Invalid selection!";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
/* If call is active, change device */
|
||||
if ( self->is_call ) {
|
||||
if (self->is_call) {
|
||||
Call *this_call = &CallControl.calls[self->num];
|
||||
|
||||
if ( this_call->ttas ) {
|
||||
if (this_call->ttas) {
|
||||
|
||||
|
||||
if ( type == output ) {
|
||||
if (type == output) {
|
||||
pthread_mutex_lock(&this_call->mutex);
|
||||
close_device(output, this_call->out_idx);
|
||||
this_call->has_output = open_device(output, selection, &this_call->out_idx,
|
||||
@ -756,27 +804,32 @@ void cmd_ccur_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*a
|
||||
|
||||
return;
|
||||
on_error:
|
||||
print_err (self, error_str);
|
||||
print_err(self, error_str);
|
||||
}
|
||||
|
||||
void cmd_mute(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
|
||||
{
|
||||
const char *error_str;
|
||||
|
||||
if ( argc != 1 ) {
|
||||
if ( argc < 1 ) error_str = "Type must be specified!";
|
||||
else error_str = "Only two arguments allowed!";
|
||||
if (argc != 1) {
|
||||
if (argc < 1) {
|
||||
error_str = "Type must be specified!";
|
||||
} else {
|
||||
error_str = "Only two arguments allowed!";
|
||||
}
|
||||
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
DeviceType type;
|
||||
|
||||
if ( strcasecmp(argv[1], "in") == 0 ) /* Input devices */
|
||||
if (strcasecmp(argv[1], "in") == 0) { /* Input devices */
|
||||
type = input;
|
||||
}
|
||||
|
||||
else if ( strcasecmp(argv[1], "out") == 0 ) /* Output devices */
|
||||
else if (strcasecmp(argv[1], "out") == 0) { /* Output devices */
|
||||
type = output;
|
||||
}
|
||||
|
||||
else {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid type: %s", argv[1]);
|
||||
@ -785,12 +838,12 @@ void cmd_mute(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MA
|
||||
|
||||
|
||||
/* If call is active, use this_call values */
|
||||
if ( self->is_call ) {
|
||||
if (self->is_call) {
|
||||
Call *this_call = &CallControl.calls[self->num];
|
||||
|
||||
pthread_mutex_lock(&this_call->mutex);
|
||||
|
||||
if ( type == input ) {
|
||||
if (type == input) {
|
||||
device_mute(type, this_call->in_idx);
|
||||
self->chatwin->infobox.in_is_muted ^= 1;
|
||||
} else {
|
||||
@ -804,16 +857,19 @@ void cmd_mute(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MA
|
||||
return;
|
||||
|
||||
on_error:
|
||||
print_err (self, error_str);
|
||||
print_err(self, error_str);
|
||||
}
|
||||
|
||||
void cmd_sense(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
|
||||
{
|
||||
const char *error_str;
|
||||
|
||||
if ( argc != 1 ) {
|
||||
if ( argc < 1 ) error_str = "Must have value!";
|
||||
else error_str = "Only two arguments allowed!";
|
||||
if (argc != 1) {
|
||||
if (argc < 1) {
|
||||
error_str = "Must have value!";
|
||||
} else {
|
||||
error_str = "Only two arguments allowed!";
|
||||
}
|
||||
|
||||
goto on_error;
|
||||
}
|
||||
@ -821,13 +877,13 @@ void cmd_sense(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[M
|
||||
char *end;
|
||||
float value = strtof(argv[1], &end);
|
||||
|
||||
if ( *end ) {
|
||||
if (*end) {
|
||||
error_str = "Invalid input";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
/* Call must be active */
|
||||
if ( self->is_call ) {
|
||||
if (self->is_call) {
|
||||
device_set_VAD_treshold(CallControl.calls[self->num].in_idx, value);
|
||||
self->chatwin->infobox.vad_lvl = value;
|
||||
}
|
||||
@ -835,19 +891,19 @@ void cmd_sense(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[M
|
||||
return;
|
||||
|
||||
on_error:
|
||||
print_err (self, error_str);
|
||||
print_err(self, error_str);
|
||||
}
|
||||
|
||||
void cmd_bitrate(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
|
||||
{
|
||||
char *error_str;
|
||||
|
||||
if ( argc != 1 ) {
|
||||
if (argc != 1) {
|
||||
error_str = "Must have value!";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if ( self->is_call == false ) {
|
||||
if (self->is_call == false) {
|
||||
error_str = "Must be in a call";
|
||||
goto on_error;
|
||||
}
|
||||
@ -885,12 +941,12 @@ void cmd_bitrate(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)
|
||||
return;
|
||||
|
||||
on_error:
|
||||
print_err (self, error_str);
|
||||
print_err(self, error_str);
|
||||
}
|
||||
|
||||
void stop_current_call(ToxWindow *self)
|
||||
{
|
||||
if ( CallControl.pending_call ) {
|
||||
if (CallControl.pending_call) {
|
||||
toxav_call_control(CallControl.av, self->num, TOXAV_CALL_CONTROL_CANCEL, NULL);
|
||||
callback_call_canceled(self->num);
|
||||
} else {
|
||||
|
@ -103,13 +103,15 @@ DeviceError init_devices()
|
||||
get_devices_names();
|
||||
|
||||
// Start poll thread
|
||||
if (pthread_mutex_init(&mutex, NULL) != 0)
|
||||
if (pthread_mutex_init(&mutex, NULL) != 0) {
|
||||
return de_InternalError;
|
||||
}
|
||||
|
||||
pthread_t thread_id;
|
||||
|
||||
if ( pthread_create(&thread_id, NULL, thread_poll, NULL) != 0 || pthread_detach(thread_id) != 0)
|
||||
if (pthread_create(&thread_id, NULL, thread_poll, NULL) != 0 || pthread_detach(thread_id) != 0) {
|
||||
return de_InternalError;
|
||||
}
|
||||
|
||||
#ifdef AUDIO
|
||||
av = av_;
|
||||
@ -127,8 +129,9 @@ DeviceError terminate_devices()
|
||||
|
||||
usleep(20000);
|
||||
|
||||
if (pthread_mutex_destroy(&mutex) != 0)
|
||||
if (pthread_mutex_destroy(&mutex) != 0) {
|
||||
return (DeviceError) de_InternalError;
|
||||
}
|
||||
|
||||
return (DeviceError) de_None;
|
||||
}
|
||||
@ -140,35 +143,38 @@ void get_devices_names()
|
||||
|
||||
size[input] = 0;
|
||||
|
||||
if ( (stringed_device_list = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER)) ) {
|
||||
if ((stringed_device_list = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER))) {
|
||||
ddevice_names[input] = alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
|
||||
|
||||
for ( ; *stringed_device_list && size[input] < MAX_DEVICES; ++size[input] ) {
|
||||
for (; *stringed_device_list && size[input] < MAX_DEVICES; ++size[input]) {
|
||||
devices_names[input][size[input]] = stringed_device_list;
|
||||
stringed_device_list += strlen( stringed_device_list ) + 1;
|
||||
stringed_device_list += strlen(stringed_device_list) + 1;
|
||||
}
|
||||
}
|
||||
|
||||
size[output] = 0;
|
||||
|
||||
if (alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT") != AL_FALSE)
|
||||
if (alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT") != AL_FALSE) {
|
||||
stringed_device_list = alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);
|
||||
else
|
||||
} else {
|
||||
stringed_device_list = alcGetString(NULL, ALC_DEVICE_SPECIFIER);
|
||||
}
|
||||
|
||||
if (stringed_device_list) {
|
||||
ddevice_names[output] = alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
|
||||
|
||||
for ( ; *stringed_device_list && size[output] < MAX_DEVICES; ++size[output] ) {
|
||||
for (; *stringed_device_list && size[output] < MAX_DEVICES; ++size[output]) {
|
||||
devices_names[output][size[output]] = stringed_device_list;
|
||||
stringed_device_list += strlen( stringed_device_list ) + 1;
|
||||
stringed_device_list += strlen(stringed_device_list) + 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
DeviceError device_mute(DeviceType type, uint32_t device_idx)
|
||||
{
|
||||
if (device_idx >= MAX_DEVICES) return de_InvalidSelection;
|
||||
if (device_idx >= MAX_DEVICES) {
|
||||
return de_InvalidSelection;
|
||||
}
|
||||
|
||||
lock;
|
||||
|
||||
@ -188,7 +194,9 @@ DeviceError device_mute(DeviceType type, uint32_t device_idx)
|
||||
#ifdef AUDIO
|
||||
DeviceError device_set_VAD_treshold(uint32_t device_idx, float value)
|
||||
{
|
||||
if (device_idx >= MAX_DEVICES) return de_InvalidSelection;
|
||||
if (device_idx >= MAX_DEVICES) {
|
||||
return de_InvalidSelection;
|
||||
}
|
||||
|
||||
lock;
|
||||
|
||||
@ -209,7 +217,9 @@ DeviceError device_set_VAD_treshold(uint32_t device_idx, float value)
|
||||
|
||||
DeviceError set_primary_device(DeviceType type, int32_t selection)
|
||||
{
|
||||
if (size[type] <= selection || selection < 0) return de_InvalidSelection;
|
||||
if (size[type] <= selection || selection < 0) {
|
||||
return de_InvalidSelection;
|
||||
}
|
||||
|
||||
primary_device[type] = selection;
|
||||
|
||||
@ -231,9 +241,13 @@ void get_primary_device_name(DeviceType type, char *buf, int size)
|
||||
DeviceError open_device(DeviceType type, int32_t selection, uint32_t *device_idx, uint32_t sample_rate,
|
||||
uint32_t frame_duration, uint8_t channels)
|
||||
{
|
||||
if (size[type] <= selection || selection < 0) return de_InvalidSelection;
|
||||
if (size[type] <= selection || selection < 0) {
|
||||
return de_InvalidSelection;
|
||||
}
|
||||
|
||||
if (channels != 1 && channels != 2) return de_UnsupportedMode;
|
||||
if (channels != 1 && channels != 2) {
|
||||
return de_UnsupportedMode;
|
||||
}
|
||||
|
||||
lock;
|
||||
|
||||
@ -246,10 +260,12 @@ DeviceError open_device(DeviceType type, int32_t selection, uint32_t *device_idx
|
||||
if (i == MAX_DEVICES) {
|
||||
unlock;
|
||||
return de_AllDevicesBusy;
|
||||
} else *device_idx = i;
|
||||
} else {
|
||||
*device_idx = i;
|
||||
}
|
||||
|
||||
for (i = 0; i < MAX_DEVICES; i ++) { /* Check if any device has the same selection */
|
||||
if ( running[type][i] && running[type][i]->selection == selection ) {
|
||||
if (running[type][i] && running[type][i]->selection == selection) {
|
||||
// printf("a%d-%d:%p ", selection, i, running[type][i]->dhndl);
|
||||
|
||||
running[type][*device_idx] = running[type][i];
|
||||
@ -282,7 +298,7 @@ DeviceError open_device(DeviceType type, int32_t selection, uint32_t *device_idx
|
||||
} else {
|
||||
device->dhndl = alcOpenDevice(devices_names[type][selection]);
|
||||
|
||||
if ( !device->dhndl ) {
|
||||
if (!device->dhndl) {
|
||||
free(device);
|
||||
running[type][*device_idx] = NULL;
|
||||
unlock;
|
||||
@ -299,7 +315,7 @@ DeviceError open_device(DeviceType type, int32_t selection, uint32_t *device_idx
|
||||
uint16_t zeros[frame_size];
|
||||
memset(zeros, 0, frame_size * 2);
|
||||
|
||||
for ( i = 0; i < OPENAL_BUFS; ++i ) {
|
||||
for (i = 0; i < OPENAL_BUFS; ++i) {
|
||||
alBufferData(device->buffers[i], device->sound_mode, zeros, frame_size * 2, sample_rate);
|
||||
}
|
||||
|
||||
@ -325,7 +341,9 @@ DeviceError open_device(DeviceType type, int32_t selection, uint32_t *device_idx
|
||||
|
||||
DeviceError close_device(DeviceType type, uint32_t device_idx)
|
||||
{
|
||||
if (device_idx >= MAX_DEVICES) return de_InvalidSelection;
|
||||
if (device_idx >= MAX_DEVICES) {
|
||||
return de_InvalidSelection;
|
||||
}
|
||||
|
||||
lock;
|
||||
Device *device = running[type][device_idx];
|
||||
@ -338,34 +356,45 @@ DeviceError close_device(DeviceType type, uint32_t device_idx)
|
||||
|
||||
running[type][device_idx] = NULL;
|
||||
|
||||
if ( !device->ref_count ) {
|
||||
if (!device->ref_count) {
|
||||
if (type == input) {
|
||||
if ( !alcCaptureCloseDevice(device->dhndl) ) rc = de_AlError;
|
||||
if (!alcCaptureCloseDevice(device->dhndl)) {
|
||||
rc = de_AlError;
|
||||
}
|
||||
} else {
|
||||
if (alcGetCurrentContext() != device->ctx) alcMakeContextCurrent(device->ctx);
|
||||
if (alcGetCurrentContext() != device->ctx) {
|
||||
alcMakeContextCurrent(device->ctx);
|
||||
}
|
||||
|
||||
alDeleteSources(1, &device->source);
|
||||
alDeleteBuffers(OPENAL_BUFS, device->buffers);
|
||||
|
||||
alcMakeContextCurrent(NULL);
|
||||
|
||||
if ( device->ctx ) alcDestroyContext(device->ctx);
|
||||
if (device->ctx) {
|
||||
alcDestroyContext(device->ctx);
|
||||
}
|
||||
|
||||
if ( !alcCloseDevice(device->dhndl) ) rc = de_AlError;
|
||||
if (!alcCloseDevice(device->dhndl)) {
|
||||
rc = de_AlError;
|
||||
}
|
||||
}
|
||||
|
||||
free(device);
|
||||
} else device->ref_count--;
|
||||
} else {
|
||||
device->ref_count--;
|
||||
}
|
||||
|
||||
unlock;
|
||||
return rc;
|
||||
}
|
||||
|
||||
DeviceError register_device_callback( int32_t friend_number, uint32_t device_idx, DataHandleCallback callback,
|
||||
void *data, bool enable_VAD)
|
||||
DeviceError register_device_callback(int32_t friend_number, uint32_t device_idx, DataHandleCallback callback,
|
||||
void *data, bool enable_VAD)
|
||||
{
|
||||
if (size[input] <= device_idx || !running[input][device_idx] || running[input][device_idx]->dhndl == NULL)
|
||||
if (size[input] <= device_idx || !running[input][device_idx] || running[input][device_idx]->dhndl == NULL) {
|
||||
return de_InvalidSelection;
|
||||
}
|
||||
|
||||
lock;
|
||||
running[input][device_idx]->cb = callback;
|
||||
@ -380,11 +409,15 @@ DeviceError register_device_callback( int32_t friend_number, uint32_t device_idx
|
||||
inline__ DeviceError write_out(uint32_t device_idx, const int16_t *data, uint32_t sample_count, uint8_t channels,
|
||||
uint32_t sample_rate)
|
||||
{
|
||||
if (device_idx >= MAX_DEVICES) return de_InvalidSelection;
|
||||
if (device_idx >= MAX_DEVICES) {
|
||||
return de_InvalidSelection;
|
||||
}
|
||||
|
||||
Device *device = running[output][device_idx];
|
||||
|
||||
if (!device || device->muted) return de_DeviceNotActive;
|
||||
if (!device || device->muted) {
|
||||
return de_DeviceNotActive;
|
||||
}
|
||||
|
||||
pthread_mutex_lock(device->mutex);
|
||||
|
||||
@ -399,8 +432,9 @@ inline__ DeviceError write_out(uint32_t device_idx, const int16_t *data, uint32_
|
||||
alSourceUnqueueBuffers(device->source, processed, bufids);
|
||||
alDeleteBuffers(processed - 1, bufids + 1);
|
||||
bufid = bufids[0];
|
||||
} else if (queued < 16) alGenBuffers(1, &bufid);
|
||||
else {
|
||||
} else if (queued < 16) {
|
||||
alGenBuffers(1, &bufid);
|
||||
} else {
|
||||
pthread_mutex_unlock(device->mutex);
|
||||
return de_Busy;
|
||||
}
|
||||
@ -413,14 +447,16 @@ inline__ DeviceError write_out(uint32_t device_idx, const int16_t *data, uint32_
|
||||
ALint state;
|
||||
alGetSourcei(device->source, AL_SOURCE_STATE, &state);
|
||||
|
||||
if (state != AL_PLAYING) alSourcePlay(device->source);
|
||||
if (state != AL_PLAYING) {
|
||||
alSourcePlay(device->source);
|
||||
}
|
||||
|
||||
|
||||
pthread_mutex_unlock(device->mutex);
|
||||
return de_None;
|
||||
}
|
||||
|
||||
void *thread_poll (void *arg) // TODO: maybe use thread for every input source
|
||||
void *thread_poll(void *arg) // TODO: maybe use thread for every input source
|
||||
{
|
||||
/*
|
||||
* NOTE: We only need to poll input devices for data.
|
||||
@ -470,7 +506,9 @@ void *thread_poll (void *arg) // TODO: maybe use thread for every input source
|
||||
continue;
|
||||
}
|
||||
|
||||
if ( device->cb ) device->cb(frame, f_size, device->cb_data);
|
||||
if (device->cb) {
|
||||
device->cb(frame, f_size, device->cb_data);
|
||||
}
|
||||
}
|
||||
|
||||
unlock;
|
||||
@ -502,8 +540,9 @@ DeviceError selection_valid(DeviceType type, int32_t selection)
|
||||
|
||||
void *get_device_callback_data(uint32_t device_idx)
|
||||
{
|
||||
if (size[input] <= device_idx || !running[input][device_idx] || running[input][device_idx]->dhndl == NULL)
|
||||
if (size[input] <= device_idx || !running[input][device_idx] || running[input][device_idx]->dhndl == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return running[input][device_idx]->cb_data;
|
||||
}
|
||||
|
@ -52,7 +52,7 @@ typedef enum DeviceError {
|
||||
de_AlError = -9,
|
||||
} DeviceError;
|
||||
|
||||
typedef void (*DataHandleCallback) (const int16_t *, uint32_t size, void *data);
|
||||
typedef void (*DataHandleCallback)(const int16_t *, uint32_t size, void *data);
|
||||
|
||||
|
||||
#ifdef AUDIO
|
||||
|
@ -97,16 +97,18 @@ int complete_line(ToxWindow *self, const void *list, size_t n_items, size_t size
|
||||
{
|
||||
ChatContext *ctx = self->chatwin;
|
||||
|
||||
if (ctx->pos <= 0 || ctx->len <= 0 || ctx->pos > ctx->len || ctx->len >= MAX_STR_SIZE || size > MAX_STR_SIZE)
|
||||
if (ctx->pos <= 0 || ctx->len <= 0 || ctx->pos > ctx->len || ctx->len >= MAX_STR_SIZE || size > MAX_STR_SIZE) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
const char *L = (char *) list;
|
||||
const char *endchrs = " ";
|
||||
char ubuf[MAX_STR_SIZE];
|
||||
|
||||
/* work with multibyte string copy of buf for simplicity */
|
||||
if (wcs_to_mbs_buf(ubuf, ctx->line, sizeof(ubuf)) == -1)
|
||||
if (wcs_to_mbs_buf(ubuf, ctx->line, sizeof(ubuf)) == -1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* TODO: generalize this */
|
||||
bool dir_search = !strncmp(ubuf, "/sendfile", strlen("/sendfile"))
|
||||
@ -124,14 +126,16 @@ int complete_line(ToxWindow *self, const void *list, size_t n_items, size_t size
|
||||
const char *s = dir_search ? strchr(tmp, '\"') : strrchr(tmp, ' ');
|
||||
char *sub = calloc(1, strlen(ubuf) + 1);
|
||||
|
||||
if (sub == NULL)
|
||||
if (sub == NULL) {
|
||||
exit_toxic_err("failed in complete_line", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
if (!s && !dir_search) {
|
||||
strcpy(sub, tmp);
|
||||
|
||||
if (sub[0] != '/')
|
||||
if (sub[0] != '/') {
|
||||
endchrs = ": ";
|
||||
}
|
||||
} else if (s) {
|
||||
strcpy(sub, &s[1]);
|
||||
|
||||
@ -139,8 +143,9 @@ int complete_line(ToxWindow *self, const void *list, size_t n_items, size_t size
|
||||
int sub_len = strlen(sub);
|
||||
int si = char_rfind(sub, '/', sub_len);
|
||||
|
||||
if (si || *sub == '/')
|
||||
if (si || *sub == '/') {
|
||||
memmove(sub, &sub[si + 1], sub_len - si);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -159,17 +164,20 @@ int complete_line(ToxWindow *self, const void *list, size_t n_items, size_t size
|
||||
char str[MAX_CMDNAME_SIZE + 1];
|
||||
snprintf(str, sizeof(str), "%s", &L[i * size]);
|
||||
|
||||
if (strncasecmp(str, sub, s_len) == 0)
|
||||
if (strncasecmp(str, sub, s_len) == 0) {
|
||||
strcpy(matches[n_matches++], str);
|
||||
}
|
||||
}
|
||||
|
||||
free(sub);
|
||||
|
||||
if (!n_matches)
|
||||
if (!n_matches) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (!dir_search && n_matches > 1)
|
||||
if (!dir_search && n_matches > 1) {
|
||||
print_matches(self, NULL, matches, n_matches, MAX_STR_SIZE);
|
||||
}
|
||||
|
||||
char match[MAX_STR_SIZE];
|
||||
size_t match_len = get_str_match(self, match, sizeof(match), matches, n_matches);
|
||||
@ -179,10 +187,11 @@ int complete_line(ToxWindow *self, const void *list, size_t n_items, size_t size
|
||||
}
|
||||
|
||||
if (dir_search) {
|
||||
if (n_matches == 1)
|
||||
if (n_matches == 1) {
|
||||
endchrs = char_rfind(match, '.', match_len) ? "\"" : "/";
|
||||
else
|
||||
} else {
|
||||
endchrs = "";
|
||||
}
|
||||
} else if (n_matches > 1) {
|
||||
endchrs = "";
|
||||
}
|
||||
@ -192,8 +201,9 @@ int complete_line(ToxWindow *self, const void *list, size_t n_items, size_t size
|
||||
int strt = ctx->pos - s_len;
|
||||
int diff = match_len - s_len + n_endchrs;
|
||||
|
||||
if (ctx->len + diff >= MAX_STR_SIZE)
|
||||
if (ctx->len + diff >= MAX_STR_SIZE) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
char tmpend[MAX_STR_SIZE];
|
||||
snprintf(tmpend, sizeof(tmpend), "%s", &ubuf[ctx->pos]);
|
||||
@ -235,13 +245,15 @@ static void complt_home_dir(ToxWindow *self, char *path, int pathsize, const cha
|
||||
|
||||
wchar_t wline[MAX_STR_SIZE];
|
||||
|
||||
if (mbs_to_wcs_buf(wline, newline, sizeof(wline) / sizeof(wchar_t)) == -1)
|
||||
if (mbs_to_wcs_buf(wline, newline, sizeof(wline) / sizeof(wchar_t)) == -1) {
|
||||
return;
|
||||
}
|
||||
|
||||
int newlen = wcslen(wline);
|
||||
|
||||
if (ctx->len + newlen >= MAX_STR_SIZE)
|
||||
if (ctx->len + newlen >= MAX_STR_SIZE) {
|
||||
return;
|
||||
}
|
||||
|
||||
wmemcpy(ctx->line, wline, newlen + 1);
|
||||
ctx->pos = newlen;
|
||||
@ -261,14 +273,17 @@ int dir_match(ToxWindow *self, Tox *m, const wchar_t *line, const wchar_t *cmd)
|
||||
char b_cmd[MAX_STR_SIZE];
|
||||
const wchar_t *tmpline = &line[wcslen(cmd) + 2]; /* start after "/command \"" */
|
||||
|
||||
if (wcs_to_mbs_buf(b_path, tmpline, sizeof(b_path)) == -1)
|
||||
if (wcs_to_mbs_buf(b_path, tmpline, sizeof(b_path)) == -1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (wcs_to_mbs_buf(b_cmd, cmd, sizeof(b_cmd)) == -1)
|
||||
if (wcs_to_mbs_buf(b_cmd, cmd, sizeof(b_cmd)) == -1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (b_path[0] == '~')
|
||||
if (b_path[0] == '~') {
|
||||
complt_home_dir(self, b_path, sizeof(b_path), b_cmd, strlen(b_cmd) + 2);
|
||||
}
|
||||
|
||||
int si = char_rfind(b_path, '/', strlen(b_path));
|
||||
|
||||
@ -286,8 +301,9 @@ int dir_match(ToxWindow *self, Tox *m, const wchar_t *line, const wchar_t *cmd)
|
||||
int b_name_len = strlen(b_name);
|
||||
DIR *dp = opendir(b_path);
|
||||
|
||||
if (dp == NULL)
|
||||
if (dp == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
char dirnames[MAX_DIRS][NAME_MAX + 1];
|
||||
struct dirent *entry;
|
||||
@ -303,8 +319,9 @@ int dir_match(ToxWindow *self, Tox *m, const wchar_t *line, const wchar_t *cmd)
|
||||
|
||||
closedir(dp);
|
||||
|
||||
if (dircount == 0)
|
||||
if (dircount == 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (dircount > 1) {
|
||||
qsort(dirnames, dircount, NAME_MAX + 1, qsort_strcasecmp_hlpr);
|
||||
|
@ -56,8 +56,9 @@ int avatar_send(Tox *m, uint32_t friendnum)
|
||||
uint32_t filenum = tox_file_send(m, friendnum, TOX_FILE_KIND_AVATAR, (size_t) Avatar.size,
|
||||
NULL, (uint8_t *) Avatar.name, Avatar.name_len, &err);
|
||||
|
||||
if (Avatar.size == 0)
|
||||
if (Avatar.size == 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (err != TOX_ERR_FILE_SEND_OK) {
|
||||
fprintf(stderr, "tox_file_send failed for friendnumber %d (error %d)\n", friendnum, err);
|
||||
@ -66,13 +67,15 @@ int avatar_send(Tox *m, uint32_t friendnum)
|
||||
|
||||
struct FileTransfer *ft = new_file_transfer(NULL, friendnum, filenum, FILE_TRANSFER_SEND, TOX_FILE_KIND_AVATAR);
|
||||
|
||||
if (!ft)
|
||||
if (!ft) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
ft->file = fopen(Avatar.path, "r");
|
||||
|
||||
if (ft->file == NULL)
|
||||
if (ft->file == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
snprintf(ft->file_name, sizeof(ft->file_name), "%s", Avatar.name);
|
||||
ft->file_size = Avatar.size;
|
||||
@ -86,8 +89,9 @@ static void avatar_send_all(Tox *m)
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < Friends.max_idx; ++i) {
|
||||
if (Friends.list[i].connection_status != TOX_CONNECTION_NONE)
|
||||
if (Friends.list[i].connection_status != TOX_CONNECTION_NONE) {
|
||||
avatar_send(m, Friends.list[i].num);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -98,13 +102,15 @@ static void avatar_send_all(Tox *m)
|
||||
*/
|
||||
int avatar_set(Tox *m, const char *path, size_t path_len)
|
||||
{
|
||||
if (path_len == 0 || path_len >= sizeof(Avatar.path))
|
||||
if (path_len == 0 || path_len >= sizeof(Avatar.path)) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
FILE *fp = fopen(path, "rb");
|
||||
|
||||
if (fp == NULL)
|
||||
if (fp == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
char PNG_signature[8] = {0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A};
|
||||
|
||||
@ -117,8 +123,9 @@ int avatar_set(Tox *m, const char *path, size_t path_len)
|
||||
|
||||
off_t size = file_size(path);
|
||||
|
||||
if (size == 0 || size > MAX_AVATAR_FILE_SIZE)
|
||||
if (size == 0 || size > MAX_AVATAR_FILE_SIZE) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
get_file_name(Avatar.name, sizeof(Avatar.name), path);
|
||||
Avatar.name_len = strlen(Avatar.name);
|
||||
@ -166,8 +173,9 @@ void on_avatar_file_control(Tox *m, struct FileTransfer *ft, TOX_FILE_CONTROL co
|
||||
|
||||
void on_avatar_chunk_request(Tox *m, struct FileTransfer *ft, uint64_t position, size_t length)
|
||||
{
|
||||
if (ft->state != FILE_TRANSFER_STARTED)
|
||||
if (ft->state != FILE_TRANSFER_STARTED) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (length == 0) {
|
||||
close_file_transfer(NULL, m, ft, -1, NULL, silent);
|
||||
@ -199,8 +207,9 @@ void on_avatar_chunk_request(Tox *m, struct FileTransfer *ft, uint64_t position,
|
||||
TOX_ERR_FILE_SEND_CHUNK err;
|
||||
tox_file_send_chunk(m, ft->friendnum, ft->filenum, position, send_data, send_length, &err);
|
||||
|
||||
if (err != TOX_ERR_FILE_SEND_CHUNK_OK)
|
||||
if (err != TOX_ERR_FILE_SEND_CHUNK_OK) {
|
||||
fprintf(stderr, "tox_file_send_chunk failed in avatar callback (error %d)\n", err);
|
||||
}
|
||||
|
||||
ft->position += send_length;
|
||||
ft->last_keep_alive = get_unix_time();
|
||||
|
236
src/chat.c
236
src/chat.c
@ -132,8 +132,9 @@ static const char chat_cmd_list[AC_NUM_CHAT_COMMANDS][MAX_CMDNAME_SIZE] = {
|
||||
|
||||
static void set_self_typingstatus(ToxWindow *self, Tox *m, bool is_typing)
|
||||
{
|
||||
if (user_settings->show_typing_self == SHOW_TYPING_OFF)
|
||||
if (user_settings->show_typing_self == SHOW_TYPING_OFF) {
|
||||
return;
|
||||
}
|
||||
|
||||
ChatContext *ctx = self->chatwin;
|
||||
|
||||
@ -197,16 +198,17 @@ static void recv_action_helper(ToxWindow *self, Tox *m, uint32_t num, const char
|
||||
|
||||
if (self->active_box != -1)
|
||||
box_notify2(self, generic_message, NT_WNDALERT_1 | NT_NOFOCUS | user_settings->bell_on_message,
|
||||
self->active_box, "* %s %s", nick, action );
|
||||
self->active_box, "* %s %s", nick, action);
|
||||
else
|
||||
box_notify(self, generic_message, NT_WNDALERT_1 | NT_NOFOCUS | user_settings->bell_on_message,
|
||||
&self->active_box, self->name, "* %s %s", nick, action );
|
||||
&self->active_box, self->name, "* %s %s", nick, action);
|
||||
}
|
||||
|
||||
static void chat_onMessage(ToxWindow *self, Tox *m, uint32_t num, TOX_MESSAGE_TYPE type, const char *msg, size_t len)
|
||||
{
|
||||
if (self->num != num)
|
||||
if (self->num != num) {
|
||||
return;
|
||||
}
|
||||
|
||||
char nick[TOX_MAX_NAME_LENGTH];
|
||||
get_nick_truncate(m, nick, num);
|
||||
@ -214,11 +216,13 @@ static void chat_onMessage(ToxWindow *self, Tox *m, uint32_t num, TOX_MESSAGE_TY
|
||||
char timefrmt[TIME_STR_SIZE];
|
||||
get_time_str(timefrmt, sizeof(timefrmt));
|
||||
|
||||
if (type == TOX_MESSAGE_TYPE_NORMAL)
|
||||
if (type == TOX_MESSAGE_TYPE_NORMAL) {
|
||||
return recv_message_helper(self, m, num, msg, len, nick, timefrmt);
|
||||
}
|
||||
|
||||
if (type == TOX_MESSAGE_TYPE_ACTION)
|
||||
if (type == TOX_MESSAGE_TYPE_ACTION) {
|
||||
return recv_action_helper(self, m, num, msg, len, nick, timefrmt);
|
||||
}
|
||||
}
|
||||
|
||||
static void chat_pause_file_transfers(Tox *m, uint32_t friendnum);
|
||||
@ -226,8 +230,9 @@ static void chat_resume_file_senders(ToxWindow *self, Tox *m, uint32_t fnum);
|
||||
|
||||
static void chat_onConnectionChange(ToxWindow *self, Tox *m, uint32_t num, TOX_CONNECTION connection_status)
|
||||
{
|
||||
if (self->num != num)
|
||||
if (self->num != num) {
|
||||
return;
|
||||
}
|
||||
|
||||
StatusBar *statusbar = self->stb;
|
||||
ChatContext *ctx = self->chatwin;
|
||||
@ -255,8 +260,9 @@ static void chat_onConnectionChange(ToxWindow *self, Tox *m, uint32_t num, TOX_C
|
||||
} else if (connection_status == TOX_CONNECTION_NONE) {
|
||||
Friends.list[num].is_typing = false;
|
||||
|
||||
if (self->chatwin->self_is_typing)
|
||||
if (self->chatwin->self_is_typing) {
|
||||
set_self_typingstatus(self, m, 0);
|
||||
}
|
||||
|
||||
chat_pause_file_transfers(m, num);
|
||||
|
||||
@ -268,16 +274,18 @@ static void chat_onConnectionChange(ToxWindow *self, Tox *m, uint32_t num, TOX_C
|
||||
|
||||
static void chat_onTypingChange(ToxWindow *self, Tox *m, uint32_t num, bool is_typing)
|
||||
{
|
||||
if (self->num != num)
|
||||
if (self->num != num) {
|
||||
return;
|
||||
}
|
||||
|
||||
Friends.list[num].is_typing = is_typing;
|
||||
}
|
||||
|
||||
static void chat_onNickChange(ToxWindow *self, Tox *m, uint32_t num, const char *nick, size_t length)
|
||||
{
|
||||
if (self->num != num)
|
||||
if (self->num != num) {
|
||||
return;
|
||||
}
|
||||
|
||||
StatusBar *statusbar = self->stb;
|
||||
|
||||
@ -290,8 +298,9 @@ static void chat_onNickChange(ToxWindow *self, Tox *m, uint32_t num, const char
|
||||
|
||||
static void chat_onStatusChange(ToxWindow *self, Tox *m, uint32_t num, TOX_USER_STATUS status)
|
||||
{
|
||||
if (self->num != num)
|
||||
if (self->num != num) {
|
||||
return;
|
||||
}
|
||||
|
||||
StatusBar *statusbar = self->stb;
|
||||
statusbar->status = status;
|
||||
@ -299,8 +308,9 @@ static void chat_onStatusChange(ToxWindow *self, Tox *m, uint32_t num, TOX_USER_
|
||||
|
||||
static void chat_onStatusMessageChange(ToxWindow *self, uint32_t num, const char *status, size_t length)
|
||||
{
|
||||
if (self->num != num)
|
||||
if (self->num != num) {
|
||||
return;
|
||||
}
|
||||
|
||||
StatusBar *statusbar = self->stb;
|
||||
|
||||
@ -321,11 +331,13 @@ static void chat_pause_file_transfers(Tox *m, uint32_t friendnum)
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < MAX_FILES; ++i) {
|
||||
if (friend->file_sender[i].state >= FILE_TRANSFER_STARTED)
|
||||
if (friend->file_sender[i].state >= FILE_TRANSFER_STARTED) {
|
||||
friend->file_sender[i].state = FILE_TRANSFER_PAUSED;
|
||||
}
|
||||
|
||||
if (friend->file_receiver[i].state >= FILE_TRANSFER_STARTED)
|
||||
if (friend->file_receiver[i].state >= FILE_TRANSFER_STARTED) {
|
||||
friend->file_receiver[i].state = FILE_TRANSFER_PAUSED;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -337,8 +349,9 @@ static void chat_resume_file_senders(ToxWindow *self, Tox *m, uint32_t friendnum
|
||||
for (i = 0; i < MAX_FILES; ++i) {
|
||||
struct FileTransfer *ft = &Friends.list[friendnum].file_sender[i];
|
||||
|
||||
if (ft->state != FILE_TRANSFER_PAUSED)
|
||||
if (ft->state != FILE_TRANSFER_PAUSED) {
|
||||
continue;
|
||||
}
|
||||
|
||||
TOX_ERR_FILE_SEND err;
|
||||
ft->filenum = tox_file_send(m, friendnum, TOX_FILE_KIND_DATA, ft->file_size, ft->file_id,
|
||||
@ -356,16 +369,19 @@ static void chat_resume_file_senders(ToxWindow *self, Tox *m, uint32_t friendnum
|
||||
static void chat_onFileChunkRequest(ToxWindow *self, Tox *m, uint32_t friendnum, uint32_t filenum, uint64_t position,
|
||||
size_t length)
|
||||
{
|
||||
if (friendnum != self->num)
|
||||
if (friendnum != self->num) {
|
||||
return;
|
||||
}
|
||||
|
||||
struct FileTransfer *ft = get_file_transfer_struct(friendnum, filenum);
|
||||
|
||||
if (!ft)
|
||||
if (!ft) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (ft->state != FILE_TRANSFER_STARTED)
|
||||
if (ft->state != FILE_TRANSFER_STARTED) {
|
||||
return;
|
||||
}
|
||||
|
||||
char msg[MAX_STR_SIZE];
|
||||
|
||||
@ -404,8 +420,9 @@ static void chat_onFileChunkRequest(ToxWindow *self, Tox *m, uint32_t friendnum,
|
||||
TOX_ERR_FILE_SEND_CHUNK err;
|
||||
tox_file_send_chunk(m, ft->friendnum, ft->filenum, position, send_data, send_length, &err);
|
||||
|
||||
if (err != TOX_ERR_FILE_SEND_CHUNK_OK)
|
||||
if (err != TOX_ERR_FILE_SEND_CHUNK_OK) {
|
||||
fprintf(stderr, "tox_file_send_chunk failed in chat callback (error %d)\n", err);
|
||||
}
|
||||
|
||||
ft->position += send_length;
|
||||
ft->bps += send_length;
|
||||
@ -415,16 +432,19 @@ static void chat_onFileChunkRequest(ToxWindow *self, Tox *m, uint32_t friendnum,
|
||||
static void chat_onFileRecvChunk(ToxWindow *self, Tox *m, uint32_t friendnum, uint32_t filenum, uint64_t position,
|
||||
const char *data, size_t length)
|
||||
{
|
||||
if (friendnum != self->num)
|
||||
if (friendnum != self->num) {
|
||||
return;
|
||||
}
|
||||
|
||||
struct FileTransfer *ft = get_file_transfer_struct(friendnum, filenum);
|
||||
|
||||
if (!ft)
|
||||
if (!ft) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (ft->state != FILE_TRANSFER_STARTED)
|
||||
if (ft->state != FILE_TRANSFER_STARTED) {
|
||||
return;
|
||||
}
|
||||
|
||||
char msg[MAX_STR_SIZE];
|
||||
|
||||
@ -454,13 +474,15 @@ static void chat_onFileRecvChunk(ToxWindow *self, Tox *m, uint32_t friendnum, ui
|
||||
|
||||
static void chat_onFileControl(ToxWindow *self, Tox *m, uint32_t friendnum, uint32_t filenum, TOX_FILE_CONTROL control)
|
||||
{
|
||||
if (friendnum != self->num)
|
||||
if (friendnum != self->num) {
|
||||
return;
|
||||
}
|
||||
|
||||
struct FileTransfer *ft = get_file_transfer_struct(friendnum, filenum);
|
||||
|
||||
if (!ft)
|
||||
if (!ft) {
|
||||
return;
|
||||
}
|
||||
|
||||
char msg[MAX_STR_SIZE];
|
||||
|
||||
@ -507,8 +529,9 @@ static bool chat_resume_broken_ft(ToxWindow *self, Tox *m, uint32_t friendnum, u
|
||||
char msg[MAX_STR_SIZE];
|
||||
uint8_t file_id[TOX_FILE_ID_LENGTH];
|
||||
|
||||
if (!tox_file_get_file_id(m, friendnum, filenum, file_id, NULL))
|
||||
if (!tox_file_get_file_id(m, friendnum, filenum, file_id, NULL)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
bool resuming = false;
|
||||
struct FileTransfer *ft = NULL;
|
||||
@ -517,8 +540,9 @@ static bool chat_resume_broken_ft(ToxWindow *self, Tox *m, uint32_t friendnum, u
|
||||
for (i = 0; i < MAX_FILES; ++i) {
|
||||
ft = &Friends.list[friendnum].file_receiver[i];
|
||||
|
||||
if (ft->state == FILE_TRANSFER_INACTIVE)
|
||||
if (ft->state == FILE_TRANSFER_INACTIVE) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (memcmp(ft->file_id, file_id, TOX_FILE_ID_LENGTH) == 0) {
|
||||
ft->filenum = filenum;
|
||||
@ -529,14 +553,17 @@ static bool chat_resume_broken_ft(ToxWindow *self, Tox *m, uint32_t friendnum, u
|
||||
}
|
||||
}
|
||||
|
||||
if (!resuming || !ft)
|
||||
if (!resuming || !ft) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!tox_file_seek(m, ft->friendnum, ft->filenum, ft->position, NULL))
|
||||
if (!tox_file_seek(m, ft->friendnum, ft->filenum, ft->position, NULL)) {
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if (!tox_file_control(m, ft->friendnum, ft->filenum, TOX_FILE_CONTROL_RESUME, NULL))
|
||||
if (!tox_file_control(m, ft->friendnum, ft->filenum, TOX_FILE_CONTROL_RESUME, NULL)) {
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
return true;
|
||||
|
||||
@ -549,12 +576,14 @@ on_error:
|
||||
static void chat_onFileRecv(ToxWindow *self, Tox *m, uint32_t friendnum, uint32_t filenum, uint64_t file_size,
|
||||
const char *filename, size_t name_length)
|
||||
{
|
||||
if (self->num != friendnum)
|
||||
if (self->num != friendnum) {
|
||||
return;
|
||||
}
|
||||
|
||||
/* first check if we need to resume a broken transfer */
|
||||
if (chat_resume_broken_ft(self, m, friendnum, filenum))
|
||||
if (chat_resume_broken_ft(self, m, friendnum, filenum)) {
|
||||
return;
|
||||
}
|
||||
|
||||
struct FileTransfer *ft = new_file_transfer(self, friendnum, filenum, FILE_TRANSFER_RECV, TOX_FILE_KIND_DATA);
|
||||
|
||||
@ -621,25 +650,28 @@ static void chat_onFileRecv(ToxWindow *self, Tox *m, uint32_t friendnum, uint32_
|
||||
|
||||
if (self->active_box != -1)
|
||||
box_notify2(self, transfer_pending, NT_WNDALERT_0 | NT_NOFOCUS | user_settings->bell_on_filetrans,
|
||||
self->active_box, "Incoming file: %s", filename );
|
||||
self->active_box, "Incoming file: %s", filename);
|
||||
else
|
||||
box_notify(self, transfer_pending, NT_WNDALERT_0 | NT_NOFOCUS | user_settings->bell_on_filetrans,
|
||||
&self->active_box, self->name, "Incoming file: %s", filename );
|
||||
&self->active_box, self->name, "Incoming file: %s", filename);
|
||||
}
|
||||
|
||||
static void chat_onGroupInvite(ToxWindow *self, Tox *m, int32_t friendnumber, uint8_t type, const char *group_pub_key,
|
||||
uint16_t length)
|
||||
{
|
||||
if (self->num != friendnumber)
|
||||
if (self->num != friendnumber) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (Friends.list[friendnumber].group_invite.key != NULL)
|
||||
if (Friends.list[friendnumber].group_invite.key != NULL) {
|
||||
free(Friends.list[friendnumber].group_invite.key);
|
||||
}
|
||||
|
||||
char *k = malloc(length);
|
||||
|
||||
if (k == NULL)
|
||||
if (k == NULL) {
|
||||
exit_toxic_err("Failed in chat_onGroupInvite", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
memcpy(k, group_pub_key, length);
|
||||
Friends.list[friendnumber].group_invite.key = k;
|
||||
@ -652,10 +684,11 @@ static void chat_onGroupInvite(ToxWindow *self, Tox *m, int32_t friendnumber, ui
|
||||
char name[TOX_MAX_NAME_LENGTH];
|
||||
get_nick_truncate(m, name, friendnumber);
|
||||
|
||||
if (self->active_box != -1)
|
||||
if (self->active_box != -1) {
|
||||
box_silent_notify2(self, NT_WNDALERT_2 | NT_NOFOCUS, self->active_box, "invites you to join group chat");
|
||||
else
|
||||
} else {
|
||||
box_silent_notify(self, NT_WNDALERT_2 | NT_NOFOCUS, &self->active_box, name, "invites you to join group chat");
|
||||
}
|
||||
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%s has invited you to a group chat.", name);
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Type \"/join\" to join the chat.");
|
||||
@ -664,44 +697,50 @@ static void chat_onGroupInvite(ToxWindow *self, Tox *m, int32_t friendnumber, ui
|
||||
/* AV Stuff */
|
||||
#ifdef AUDIO
|
||||
|
||||
void chat_onInvite (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
|
||||
void chat_onInvite(ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
|
||||
{
|
||||
if (!self || self->num != friend_number)
|
||||
if (!self || self->num != friend_number) {
|
||||
return;
|
||||
}
|
||||
|
||||
/* call is flagged active here */
|
||||
self->is_call = true;
|
||||
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Incoming audio call! Type: \"/answer\" or \"/reject\"");
|
||||
|
||||
if (self->ringing_sound == -1)
|
||||
if (self->ringing_sound == -1) {
|
||||
sound_notify(self, call_incoming, NT_LOOP | user_settings->bell_on_invite, &self->ringing_sound);
|
||||
}
|
||||
|
||||
if (self->active_box != -1)
|
||||
if (self->active_box != -1) {
|
||||
box_silent_notify2(self, NT_NOFOCUS | NT_WNDALERT_0, self->active_box, "Incoming audio call!");
|
||||
else
|
||||
} else {
|
||||
box_silent_notify(self, NT_NOFOCUS | NT_WNDALERT_0, &self->active_box, self->name, "Incoming audio call!");
|
||||
}
|
||||
}
|
||||
|
||||
void chat_onRinging (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
|
||||
void chat_onRinging(ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
|
||||
{
|
||||
if (!self || self->num != friend_number)
|
||||
if (!self || self->num != friend_number) {
|
||||
return;
|
||||
}
|
||||
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Ringing...type \"/hangup\" to cancel it.");
|
||||
|
||||
#ifdef SOUND_NOTIFY
|
||||
|
||||
if (self->ringing_sound == -1)
|
||||
if (self->ringing_sound == -1) {
|
||||
sound_notify(self, call_outgoing, NT_LOOP, &self->ringing_sound);
|
||||
}
|
||||
|
||||
#endif /* SOUND_NOTIFY */
|
||||
}
|
||||
|
||||
void chat_onStarting (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
|
||||
void chat_onStarting(ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
|
||||
{
|
||||
if (!self || self->num != friend_number)
|
||||
if (!self || self->num != friend_number) {
|
||||
return;
|
||||
}
|
||||
|
||||
init_infobox(self);
|
||||
|
||||
@ -715,10 +754,11 @@ void chat_onStarting (ToxWindow *self, ToxAV *av, uint32_t friend_number, int st
|
||||
#endif /* SOUND_NOTIFY */
|
||||
}
|
||||
|
||||
void chat_onEnding (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
|
||||
void chat_onEnding(ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
|
||||
{
|
||||
if (!self || self->num != friend_number)
|
||||
if (!self || self->num != friend_number) {
|
||||
return;
|
||||
}
|
||||
|
||||
kill_infobox(self);
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Call ended!");
|
||||
@ -730,10 +770,11 @@ void chat_onEnding (ToxWindow *self, ToxAV *av, uint32_t friend_number, int stat
|
||||
#endif /* SOUND_NOTIFY */
|
||||
}
|
||||
|
||||
void chat_onError (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
|
||||
void chat_onError(ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
|
||||
{
|
||||
if (!self || self->num != friend_number)
|
||||
if (!self || self->num != friend_number) {
|
||||
return;
|
||||
}
|
||||
|
||||
self->is_call = false;
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Error!");
|
||||
@ -743,10 +784,11 @@ void chat_onError (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state
|
||||
#endif /* SOUND_NOTIFY */
|
||||
}
|
||||
|
||||
void chat_onStart (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
|
||||
void chat_onStart(ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
|
||||
{
|
||||
if (!self || self->num != friend_number)
|
||||
if (!self || self->num != friend_number) {
|
||||
return;
|
||||
}
|
||||
|
||||
/* call is flagged active here */
|
||||
self->is_call = true;
|
||||
@ -760,10 +802,11 @@ void chat_onStart (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state
|
||||
#endif /* SOUND_NOTIFY */
|
||||
}
|
||||
|
||||
void chat_onCancel (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
|
||||
void chat_onCancel(ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
|
||||
{
|
||||
if (!self || self->num != friend_number)
|
||||
if (!self || self->num != friend_number) {
|
||||
return;
|
||||
}
|
||||
|
||||
self->is_call = false;
|
||||
kill_infobox(self);
|
||||
@ -774,10 +817,11 @@ void chat_onCancel (ToxWindow *self, ToxAV *av, uint32_t friend_number, int stat
|
||||
#endif /* SOUND_NOTIFY */
|
||||
}
|
||||
|
||||
void chat_onReject (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
|
||||
void chat_onReject(ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
|
||||
{
|
||||
if (!self || self->num != friend_number)
|
||||
if (!self || self->num != friend_number) {
|
||||
return;
|
||||
}
|
||||
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Rejected!");
|
||||
self->is_call = false;
|
||||
@ -787,10 +831,11 @@ void chat_onReject (ToxWindow *self, ToxAV *av, uint32_t friend_number, int stat
|
||||
#endif /* SOUND_NOTIFY */
|
||||
}
|
||||
|
||||
void chat_onEnd (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
|
||||
void chat_onEnd(ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
|
||||
{
|
||||
if (!self || self->num != friend_number)
|
||||
if (!self || self->num != friend_number) {
|
||||
return;
|
||||
}
|
||||
|
||||
kill_infobox(self);
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Call ended!");
|
||||
@ -808,8 +853,9 @@ static void init_infobox(ToxWindow *self)
|
||||
int x2, y2;
|
||||
getmaxyx(self->window, y2, x2);
|
||||
|
||||
if (y2 <= 0 || x2 <= 0)
|
||||
if (y2 <= 0 || x2 <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
(void) y2;
|
||||
|
||||
@ -826,8 +872,9 @@ static void kill_infobox(ToxWindow *self)
|
||||
{
|
||||
ChatContext *ctx = self->chatwin;
|
||||
|
||||
if (!ctx->infobox.win)
|
||||
if (!ctx->infobox.win) {
|
||||
return;
|
||||
}
|
||||
|
||||
delwin(ctx->infobox.win);
|
||||
memset(&ctx->infobox, 0, sizeof(struct infobox));
|
||||
@ -838,20 +885,23 @@ static void draw_infobox(ToxWindow *self)
|
||||
{
|
||||
struct infobox *infobox = &self->chatwin->infobox;
|
||||
|
||||
if (infobox->win == NULL)
|
||||
if (infobox->win == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
int x2, y2;
|
||||
getmaxyx(self->window, y2, x2);
|
||||
|
||||
if (x2 < INFOBOX_WIDTH || y2 < INFOBOX_HEIGHT)
|
||||
if (x2 < INFOBOX_WIDTH || y2 < INFOBOX_HEIGHT) {
|
||||
return;
|
||||
}
|
||||
|
||||
time_t curtime = get_unix_time();
|
||||
|
||||
/* update elapsed time string once per second */
|
||||
if (curtime > infobox->lastupdate)
|
||||
if (curtime > infobox->lastupdate) {
|
||||
get_elapsed_time_str(infobox->timestr, sizeof(infobox->timestr), curtime - infobox->starttime);
|
||||
}
|
||||
|
||||
infobox->lastupdate = curtime;
|
||||
|
||||
@ -891,8 +941,9 @@ static void draw_infobox(ToxWindow *self)
|
||||
|
||||
static void send_action(ToxWindow *self, ChatContext *ctx, Tox *m, char *action)
|
||||
{
|
||||
if (action == NULL)
|
||||
if (action == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
char selfname[TOX_MAX_NAME_LENGTH];
|
||||
tox_self_get_name(m, (uint8_t *) selfname);
|
||||
@ -916,11 +967,13 @@ static void chat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
|
||||
getyx(self->window, y, x);
|
||||
getmaxyx(self->window, y2, x2);
|
||||
|
||||
if (y2 <= 0 || x2 <= 0)
|
||||
if (y2 <= 0 || x2 <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (ctx->pastemode && key == '\r')
|
||||
if (ctx->pastemode && key == '\r') {
|
||||
key = '\n';
|
||||
}
|
||||
|
||||
if (self->help->active) {
|
||||
help_onKey(self, key);
|
||||
@ -930,14 +983,16 @@ static void chat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
|
||||
if (ltr || key == '\n') { /* char is printable */
|
||||
input_new_char(self, key, x, y, x2, y2);
|
||||
|
||||
if (ctx->line[0] != '/' && !ctx->self_is_typing && statusbar->connection != TOX_CONNECTION_NONE)
|
||||
if (ctx->line[0] != '/' && !ctx->self_is_typing && statusbar->connection != TOX_CONNECTION_NONE) {
|
||||
set_self_typingstatus(self, m, 1);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if (line_info_onKey(self, key))
|
||||
if (line_info_onKey(self, key)) {
|
||||
return;
|
||||
}
|
||||
|
||||
input_handle(self, key, x, y, x2, y2);
|
||||
|
||||
@ -988,8 +1043,9 @@ static void chat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
|
||||
|
||||
char line[MAX_STR_SIZE] = {0};
|
||||
|
||||
if (wcs_to_mbs_buf(line, ctx->line, MAX_STR_SIZE) == -1)
|
||||
if (wcs_to_mbs_buf(line, ctx->line, MAX_STR_SIZE) == -1) {
|
||||
memset(&line, 0, sizeof(line));
|
||||
}
|
||||
|
||||
if (line[0] == '/') {
|
||||
if (strcmp(line, "/close") == 0) {
|
||||
@ -1020,8 +1076,9 @@ static void chat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
|
||||
reset_buf(ctx);
|
||||
}
|
||||
|
||||
if (ctx->len <= 0 && ctx->self_is_typing)
|
||||
if (ctx->len <= 0 && ctx->self_is_typing) {
|
||||
set_self_typingstatus(self, m, 0);
|
||||
}
|
||||
}
|
||||
|
||||
static void chat_onDraw(ToxWindow *self, Tox *m)
|
||||
@ -1029,8 +1086,9 @@ static void chat_onDraw(ToxWindow *self, Tox *m)
|
||||
int x2, y2;
|
||||
getmaxyx(self->window, y2, x2);
|
||||
|
||||
if (y2 <= 0 || x2 <= 0)
|
||||
if (y2 <= 0 || x2 <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
ChatContext *ctx = self->chatwin;
|
||||
|
||||
@ -1042,8 +1100,9 @@ static void chat_onDraw(ToxWindow *self, Tox *m)
|
||||
|
||||
curs_set(1);
|
||||
|
||||
if (ctx->len > 0)
|
||||
if (ctx->len > 0) {
|
||||
mvwprintw(ctx->linewin, 1, 0, "%ls", &ctx->line[ctx->start]);
|
||||
}
|
||||
|
||||
/* Draw status bar */
|
||||
StatusBar *statusbar = self->stb;
|
||||
@ -1073,15 +1132,17 @@ static void chat_onDraw(ToxWindow *self, Tox *m)
|
||||
wprintw(statusbar->topline, " %s", ONLINE_CHAR);
|
||||
wattroff(statusbar->topline, COLOR_PAIR(colour) | A_BOLD);
|
||||
|
||||
if (Friends.list[self->num].is_typing)
|
||||
if (Friends.list[self->num].is_typing) {
|
||||
wattron(statusbar->topline, COLOR_PAIR(YELLOW));
|
||||
}
|
||||
|
||||
wattron(statusbar->topline, A_BOLD);
|
||||
wprintw(statusbar->topline, " %s ", statusbar->nick);
|
||||
wattroff(statusbar->topline, A_BOLD);
|
||||
|
||||
if (Friends.list[self->num].is_typing)
|
||||
if (Friends.list[self->num].is_typing) {
|
||||
wattroff(statusbar->topline, COLOR_PAIR(YELLOW));
|
||||
}
|
||||
} else {
|
||||
wprintw(statusbar->topline, " %s", OFFLINE_CHAR);
|
||||
wattron(statusbar->topline, A_BOLD);
|
||||
@ -1114,8 +1175,9 @@ static void chat_onDraw(ToxWindow *self, Tox *m)
|
||||
statusbar->statusmsg_len = maxlen;
|
||||
}
|
||||
|
||||
if (statusbar->statusmsg[0])
|
||||
if (statusbar->statusmsg[0]) {
|
||||
wprintw(statusbar->topline, ": %s ", statusbar->statusmsg);
|
||||
}
|
||||
|
||||
wclrtoeol(statusbar->topline);
|
||||
wmove(statusbar->topline, 0, x2 - (KEY_IDENT_DIGITS * 2) - 3);
|
||||
@ -1123,8 +1185,9 @@ static void chat_onDraw(ToxWindow *self, Tox *m)
|
||||
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < KEY_IDENT_DIGITS; ++i)
|
||||
for (i = 0; i < KEY_IDENT_DIGITS; ++i) {
|
||||
wprintw(statusbar->topline, "%02X", Friends.list[self->num].pub_key[i] & 0xff);
|
||||
}
|
||||
|
||||
wprintw(statusbar->topline, "}\n");
|
||||
|
||||
@ -1146,8 +1209,9 @@ static void chat_onDraw(ToxWindow *self, Tox *m)
|
||||
|
||||
#endif
|
||||
|
||||
if (self->help->active)
|
||||
if (self->help->active) {
|
||||
help_onDraw(self);
|
||||
}
|
||||
|
||||
pthread_mutex_lock(&Winthread.lock);
|
||||
refresh_file_transfer_progress(self, m, self->num);
|
||||
@ -1160,8 +1224,9 @@ static void chat_onInit(ToxWindow *self, Tox *m)
|
||||
int x2, y2;
|
||||
getmaxyx(self->window, y2, x2);
|
||||
|
||||
if (y2 <= 0 || x2 <= 0)
|
||||
if (y2 <= 0 || x2 <= 0) {
|
||||
exit_toxic_err("failed in chat_onInit", FATALERR_CURSES);
|
||||
}
|
||||
|
||||
self->x = x2;
|
||||
|
||||
@ -1196,8 +1261,9 @@ static void chat_onInit(ToxWindow *self, Tox *m)
|
||||
ctx->log = calloc(1, sizeof(struct chatlog));
|
||||
ctx->cqueue = calloc(1, sizeof(struct chat_queue));
|
||||
|
||||
if (ctx->log == NULL || ctx->hst == NULL || ctx->cqueue == NULL)
|
||||
if (ctx->log == NULL || ctx->hst == NULL || ctx->cqueue == NULL) {
|
||||
exit_toxic_err("failed in chat_onInit", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
line_info_init(ctx->hst);
|
||||
|
||||
@ -1207,10 +1273,11 @@ static void chat_onInit(ToxWindow *self, Tox *m)
|
||||
int log_ret = log_enable(nick, myid, Friends.list[self->num].pub_key, ctx->log, LOG_CHAT);
|
||||
load_chat_history(self, ctx->log);
|
||||
|
||||
if (!Friends.list[self->num].logging_on)
|
||||
if (!Friends.list[self->num].logging_on) {
|
||||
log_disable(ctx->log);
|
||||
else if (log_ret == -1)
|
||||
} else if (log_ret == -1) {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Warning: Log failed to initialize.");
|
||||
}
|
||||
|
||||
execute(ctx->history, self, m, "/log", GLOBAL_COMMAND_MODE);
|
||||
|
||||
@ -1268,8 +1335,9 @@ ToxWindow new_chat(Tox *m, uint32_t friendnum)
|
||||
StatusBar *stb = calloc(1, sizeof(StatusBar));
|
||||
Help *help = calloc(1, sizeof(Help));
|
||||
|
||||
if (stb == NULL || chatwin == NULL || help == NULL)
|
||||
if (stb == NULL || chatwin == NULL || help == NULL) {
|
||||
exit_toxic_err("failed in new_chat", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
ret.chatwin = chatwin;
|
||||
ret.stb = stb;
|
||||
|
@ -175,8 +175,9 @@ void cmd_savefile(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv
|
||||
TOX_ERR_FILE_CONTROL err;
|
||||
tox_file_control(m, self->num, ft->filenum, TOX_FILE_CONTROL_RESUME, &err);
|
||||
|
||||
if (err != TOX_ERR_FILE_CONTROL_OK)
|
||||
if (err != TOX_ERR_FILE_CONTROL_OK) {
|
||||
goto on_recv_error;
|
||||
}
|
||||
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Saving file [%d] as: '%s'", idx, ft->file_path);
|
||||
|
||||
@ -262,8 +263,9 @@ void cmd_sendfile(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv
|
||||
uint32_t filenum = tox_file_send(m, self->num, TOX_FILE_KIND_DATA, (uint64_t) filesize, NULL,
|
||||
(uint8_t *) file_name, namelen, &err);
|
||||
|
||||
if (err != TOX_ERR_FILE_SEND_OK)
|
||||
if (err != TOX_ERR_FILE_SEND_OK) {
|
||||
goto on_send_error;
|
||||
}
|
||||
|
||||
struct FileTransfer *ft = new_file_transfer(self, self->num, filenum, FILE_TRANSFER_SEND, TOX_FILE_KIND_DATA);
|
||||
|
||||
|
@ -48,8 +48,9 @@ void get_home_dir(char *home, int size)
|
||||
} else {
|
||||
hmstr = getenv("HOME");
|
||||
|
||||
if (hmstr == NULL)
|
||||
if (hmstr == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
snprintf(buf, sizeof(buf), "%s", hmstr);
|
||||
hmstr = buf;
|
||||
@ -77,8 +78,9 @@ char *get_user_config_dir(void)
|
||||
len = strlen(home) + strlen("/Library/Application Support") + 1;
|
||||
user_config_dir = malloc(len);
|
||||
|
||||
if (user_config_dir == NULL)
|
||||
if (user_config_dir == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
snprintf(user_config_dir, len, "%s/Library/Application Support", home);
|
||||
# else /* __APPLE__ */
|
||||
@ -89,8 +91,9 @@ char *get_user_config_dir(void)
|
||||
len = strlen(home) + strlen("/.config") + 1;
|
||||
user_config_dir = malloc(len);
|
||||
|
||||
if (user_config_dir == NULL)
|
||||
if (user_config_dir == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
snprintf(user_config_dir, len, "%s/.config", home);
|
||||
} else {
|
||||
@ -112,14 +115,16 @@ int create_user_config_dirs(char *path)
|
||||
struct stat buf;
|
||||
int mkdir_err = mkdir(path, 0700);
|
||||
|
||||
if (mkdir_err && (errno != EEXIST || stat(path, &buf) || !S_ISDIR(buf.st_mode)))
|
||||
if (mkdir_err && (errno != EEXIST || stat(path, &buf) || !S_ISDIR(buf.st_mode))) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
char *fullpath = malloc(strlen(path) + strlen(CONFIGDIR) + 1);
|
||||
char *logpath = malloc(strlen(path) + strlen(LOGDIR) + 1);
|
||||
|
||||
if (fullpath == NULL || logpath == NULL)
|
||||
if (fullpath == NULL || logpath == NULL) {
|
||||
exit_toxic_err("failed in load_data_structures", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
strcpy(fullpath, path);
|
||||
strcat(fullpath, CONFIGDIR);
|
||||
|
@ -36,8 +36,9 @@
|
||||
*/
|
||||
int set_curl_proxy(CURL *c_handle, const char *proxy_address, uint16_t port, uint8_t proxy_type)
|
||||
{
|
||||
if (proxy_type == TOX_PROXY_TYPE_NONE)
|
||||
if (proxy_type == TOX_PROXY_TYPE_NONE) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (proxy_address == NULL || port == 0) {
|
||||
return -1;
|
||||
|
@ -113,8 +113,9 @@ static int parse_command(WINDOW *w, ToxWindow *self, const char *input, char (*a
|
||||
{
|
||||
char *cmd = strdup(input);
|
||||
|
||||
if (cmd == NULL)
|
||||
if (cmd == NULL) {
|
||||
exit_toxic_err("failed in parse_command", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
int num_args = 0;
|
||||
int i = 0; /* index of last char in an argument */
|
||||
@ -140,8 +141,9 @@ static int parse_command(WINDOW *w, ToxWindow *self, const char *input, char (*a
|
||||
memcpy(args[num_args], cmd, i + qt_ofst);
|
||||
args[num_args++][i + qt_ofst] = '\0';
|
||||
|
||||
if (cmd[i] == '\0') /* no more args */
|
||||
if (cmd[i] == '\0') { /* no more args */
|
||||
break;
|
||||
}
|
||||
|
||||
char tmp[MAX_STR_SIZE];
|
||||
snprintf(tmp, sizeof(tmp), "%s", &cmd[i + 1]);
|
||||
@ -170,14 +172,16 @@ static int do_command(WINDOW *w, ToxWindow *self, Tox *m, int num_args, struct c
|
||||
|
||||
void execute(WINDOW *w, ToxWindow *self, Tox *m, const char *input, int mode)
|
||||
{
|
||||
if (string_is_empty(input))
|
||||
if (string_is_empty(input)) {
|
||||
return;
|
||||
}
|
||||
|
||||
char args[MAX_NUM_ARGS][MAX_STR_SIZE];
|
||||
int num_args = parse_command(w, self, input, args);
|
||||
|
||||
if (num_args == -1)
|
||||
if (num_args == -1) {
|
||||
return;
|
||||
}
|
||||
|
||||
/* Try to match input command to command functions. If non-global command mode is specified,
|
||||
try specified mode's commands first, then upon failure try global commands.
|
||||
@ -185,25 +189,29 @@ void execute(WINDOW *w, ToxWindow *self, Tox *m, const char *input, int mode)
|
||||
Note: Global commands must come last in case of duplicate command names */
|
||||
switch (mode) {
|
||||
case CHAT_COMMAND_MODE:
|
||||
if (do_command(w, self, m, num_args, chat_commands, args) == 0)
|
||||
if (do_command(w, self, m, num_args, chat_commands, args) == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case GROUPCHAT_COMMAND_MODE:
|
||||
if (do_command(w, self, m, num_args, group_commands, args) == 0)
|
||||
if (do_command(w, self, m, num_args, group_commands, args) == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
if (do_command(w, self, m, num_args, global_commands, args) == 0)
|
||||
if (do_command(w, self, m, num_args, global_commands, args) == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
#ifdef PYTHON
|
||||
|
||||
if (do_plugin_command(num_args, args) == 0)
|
||||
if (do_plugin_command(num_args, args) == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
@ -45,8 +45,9 @@ void init_progress_bar(char *progline)
|
||||
strcpy(progline, "0% [");
|
||||
int i;
|
||||
|
||||
for (i = 0; i < NUM_PROG_MARKS; ++i)
|
||||
for (i = 0; i < NUM_PROG_MARKS; ++i) {
|
||||
strcat(progline, "-");
|
||||
}
|
||||
|
||||
strcat(progline, "] 0.0 B/s");
|
||||
}
|
||||
@ -54,8 +55,9 @@ void init_progress_bar(char *progline)
|
||||
/* prints a progress bar for file transfers. */
|
||||
void print_progress_bar(ToxWindow *self, double bps, double pct_done, uint32_t line_id)
|
||||
{
|
||||
if (bps < 0 || pct_done < 0 || pct_done > 100)
|
||||
if (bps < 0 || pct_done < 0 || pct_done > 100) {
|
||||
return;
|
||||
}
|
||||
|
||||
char pct_str[24];
|
||||
snprintf(pct_str, sizeof(pct_str), "%.1f%%", pct_done);
|
||||
@ -67,14 +69,17 @@ void print_progress_bar(ToxWindow *self, double bps, double pct_done, uint32_t l
|
||||
int n = pct_done / (100 / NUM_PROG_MARKS);
|
||||
int i, j;
|
||||
|
||||
for (i = 0; i < n; ++i)
|
||||
for (i = 0; i < n; ++i) {
|
||||
strcat(prog_line, "=");
|
||||
}
|
||||
|
||||
if (pct_done < 100)
|
||||
if (pct_done < 100) {
|
||||
strcpy(prog_line + n, ">");
|
||||
}
|
||||
|
||||
for (j = i; j < NUM_PROG_MARKS - 1; ++j)
|
||||
for (j = i; j < NUM_PROG_MARKS - 1; ++j) {
|
||||
strcat(prog_line, "-");
|
||||
}
|
||||
|
||||
char full_line[strlen(pct_str) + NUM_PROG_MARKS + strlen(bps_str) + 7];
|
||||
snprintf(full_line, sizeof(full_line), "%s [%s] %s/s", pct_str, prog_line, bps_str);
|
||||
@ -84,12 +89,14 @@ void print_progress_bar(ToxWindow *self, double bps, double pct_done, uint32_t l
|
||||
|
||||
static void refresh_progress_helper(ToxWindow *self, Tox *m, struct FileTransfer *ft)
|
||||
{
|
||||
if (ft->state == FILE_TRANSFER_INACTIVE)
|
||||
if (ft->state == FILE_TRANSFER_INACTIVE) {
|
||||
return;
|
||||
}
|
||||
|
||||
/* Timeout must be set to 1 second to show correct bytes per second */
|
||||
if (!timed_out(ft->last_line_progress, 1))
|
||||
if (!timed_out(ft->last_line_progress, 1)) {
|
||||
return;
|
||||
}
|
||||
|
||||
double remain = ft->file_size - ft->position;
|
||||
double pct_done = remain > 0 ? (1 - (remain / ft->file_size)) * 100 : 100;
|
||||
@ -120,13 +127,15 @@ struct FileTransfer *get_file_transfer_struct(uint32_t friendnum, uint32_t filen
|
||||
for (i = 0; i < MAX_FILES; ++i) {
|
||||
struct FileTransfer *ft_send = &Friends.list[friendnum].file_sender[i];
|
||||
|
||||
if (ft_send->state != FILE_TRANSFER_INACTIVE && ft_send->filenum == filenum)
|
||||
if (ft_send->state != FILE_TRANSFER_INACTIVE && ft_send->filenum == filenum) {
|
||||
return ft_send;
|
||||
}
|
||||
|
||||
struct FileTransfer *ft_recv = &Friends.list[friendnum].file_receiver[i];
|
||||
|
||||
if (ft_recv->state != FILE_TRANSFER_INACTIVE && ft_recv->filenum == filenum)
|
||||
if (ft_recv->state != FILE_TRANSFER_INACTIVE && ft_recv->filenum == filenum) {
|
||||
return ft_recv;
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
@ -138,8 +147,9 @@ struct FileTransfer *get_file_transfer_struct(uint32_t friendnum, uint32_t filen
|
||||
struct FileTransfer *get_file_transfer_struct_index(uint32_t friendnum, uint32_t index,
|
||||
FILE_TRANSFER_DIRECTION direction)
|
||||
{
|
||||
if (direction != FILE_TRANSFER_RECV && direction != FILE_TRANSFER_SEND)
|
||||
if (direction != FILE_TRANSFER_RECV && direction != FILE_TRANSFER_SEND) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
size_t i;
|
||||
|
||||
@ -148,8 +158,9 @@ struct FileTransfer *get_file_transfer_struct_index(uint32_t friendnum, uint32_t
|
||||
&Friends.list[friendnum].file_sender[i] :
|
||||
&Friends.list[friendnum].file_receiver[i];
|
||||
|
||||
if (ft->state != FILE_TRANSFER_INACTIVE && ft->index == index)
|
||||
if (ft->state != FILE_TRANSFER_INACTIVE && ft->index == index) {
|
||||
return ft;
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
@ -215,11 +226,13 @@ static struct FileTransfer *new_file_receiver(ToxWindow *window, uint32_t friend
|
||||
struct FileTransfer *new_file_transfer(ToxWindow *window, uint32_t friendnum, uint32_t filenum,
|
||||
FILE_TRANSFER_DIRECTION direction, uint8_t type)
|
||||
{
|
||||
if (direction == FILE_TRANSFER_RECV)
|
||||
if (direction == FILE_TRANSFER_RECV) {
|
||||
return new_file_receiver(window, friendnum, filenum, type);
|
||||
}
|
||||
|
||||
if (direction == FILE_TRANSFER_SEND)
|
||||
if (direction == FILE_TRANSFER_SEND) {
|
||||
return new_file_sender(window, friendnum, filenum, type);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
@ -233,23 +246,28 @@ struct FileTransfer *new_file_transfer(ToxWindow *window, uint32_t friendnum, ui
|
||||
void close_file_transfer(ToxWindow *self, Tox *m, struct FileTransfer *ft, int CTRL, const char *message,
|
||||
Notification sound_type)
|
||||
{
|
||||
if (!ft)
|
||||
if (!ft) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (ft->state == FILE_TRANSFER_INACTIVE)
|
||||
if (ft->state == FILE_TRANSFER_INACTIVE) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (ft->file)
|
||||
if (ft->file) {
|
||||
fclose(ft->file);
|
||||
}
|
||||
|
||||
if (CTRL >= 0)
|
||||
if (CTRL >= 0) {
|
||||
tox_file_control(m, ft->friendnum, ft->filenum, (TOX_FILE_CONTROL) CTRL, NULL);
|
||||
}
|
||||
|
||||
if (message && self) {
|
||||
if (self->active_box != -1 && sound_type != silent)
|
||||
if (self->active_box != -1 && sound_type != silent) {
|
||||
box_notify2(self, sound_type, NT_NOFOCUS | NT_WNDALERT_2, self->active_box, "%s", message);
|
||||
else
|
||||
} else {
|
||||
box_notify(self, sound_type, NT_NOFOCUS | NT_WNDALERT_2, &self->active_box, self->name, "%s", message);
|
||||
}
|
||||
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%s", message);
|
||||
}
|
||||
@ -272,6 +290,7 @@ void kill_all_file_transfers(Tox *m)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < Friends.max_idx; ++i)
|
||||
for (i = 0; i < Friends.max_idx; ++i) {
|
||||
kill_all_file_transfers_friend(m, Friends.list[i].num);
|
||||
}
|
||||
}
|
||||
|
197
src/friendlist.c
197
src/friendlist.c
@ -84,8 +84,9 @@ static void realloc_friends(int n)
|
||||
ToxicFriend *f = realloc(Friends.list, n * sizeof(ToxicFriend));
|
||||
uint32_t *f_idx = realloc(Friends.index, n * sizeof(uint32_t));
|
||||
|
||||
if (f == NULL || f_idx == NULL)
|
||||
if (f == NULL || f_idx == NULL) {
|
||||
exit_toxic_err("failed in realloc_friends", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
Friends.list = f;
|
||||
Friends.index = f_idx;
|
||||
@ -104,8 +105,9 @@ static void realloc_blocklist(int n)
|
||||
BlockedFriend *b = realloc(Blocked.list, n * sizeof(BlockedFriend));
|
||||
uint32_t *b_idx = realloc(Blocked.index, n * sizeof(uint32_t));
|
||||
|
||||
if (b == NULL || b_idx == NULL)
|
||||
if (b == NULL || b_idx == NULL) {
|
||||
exit_toxic_err("failed in realloc_blocklist", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
Blocked.list = b;
|
||||
Blocked.index = b_idx;
|
||||
@ -116,8 +118,9 @@ void kill_friendlist(void)
|
||||
int i;
|
||||
|
||||
for (i = 0; i < Friends.max_idx; ++i) {
|
||||
if (Friends.list[i].active && Friends.list[i].group_invite.key != NULL)
|
||||
if (Friends.list[i].active && Friends.list[i].group_invite.key != NULL) {
|
||||
free(Friends.list[i].group_invite.key);
|
||||
}
|
||||
}
|
||||
|
||||
realloc_blocklist(0);
|
||||
@ -215,13 +218,15 @@ static void sort_blocklist_index(void);
|
||||
|
||||
int load_blocklist(char *path)
|
||||
{
|
||||
if (path == NULL)
|
||||
if (path == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
FILE *fp = fopen(path, "rb");
|
||||
|
||||
if (fp == NULL)
|
||||
if (fp == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
off_t len = file_size(path);
|
||||
|
||||
@ -298,8 +303,9 @@ void sort_friendlist_index(void)
|
||||
uint32_t n = 0;
|
||||
|
||||
for (i = 0; i < Friends.max_idx; ++i) {
|
||||
if (Friends.list[i].active)
|
||||
if (Friends.list[i].active) {
|
||||
Friends.index[n++] = Friends.list[i].num;
|
||||
}
|
||||
}
|
||||
|
||||
qsort(Friends.index, Friends.num_friends, sizeof(uint32_t), index_name_cmp);
|
||||
@ -316,8 +322,9 @@ static void sort_blocklist_index(void)
|
||||
uint32_t n = 0;
|
||||
|
||||
for (i = 0; i < Blocked.max_idx; ++i) {
|
||||
if (Blocked.list[i].active)
|
||||
if (Blocked.list[i].active) {
|
||||
Blocked.index[n++] = Blocked.list[i].num;
|
||||
}
|
||||
}
|
||||
|
||||
qsort(Blocked.index, Blocked.num_blocked, sizeof(uint32_t), index_name_cmp_block);
|
||||
@ -337,11 +344,13 @@ static void update_friend_last_online(uint32_t num, time_t timestamp)
|
||||
static void friendlist_onMessage(ToxWindow *self, Tox *m, uint32_t num, TOX_MESSAGE_TYPE type, const char *str,
|
||||
size_t length)
|
||||
{
|
||||
if (num >= Friends.max_idx)
|
||||
if (num >= Friends.max_idx) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (Friends.list[num].chatwin != -1)
|
||||
if (Friends.list[num].chatwin != -1) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (get_num_active_windows() < MAX_WINDOWS_NUM) {
|
||||
Friends.list[num].chatwin = add_window(m, new_chat(m, Friends.list[num].num));
|
||||
@ -361,16 +370,18 @@ static void friendlist_onMessage(ToxWindow *self, Tox *m, uint32_t num, TOX_MESS
|
||||
|
||||
static void friendlist_onConnectionChange(ToxWindow *self, Tox *m, uint32_t num, TOX_CONNECTION connection_status)
|
||||
{
|
||||
if (num >= Friends.max_idx)
|
||||
if (num >= Friends.max_idx) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (connection_status == TOX_CONNECTION_NONE) {
|
||||
--Friends.num_online;
|
||||
} else if (Friends.list[num].connection_status == TOX_CONNECTION_NONE) {
|
||||
++Friends.num_online;
|
||||
|
||||
if (avatar_send(m, num) == -1)
|
||||
if (avatar_send(m, num) == -1) {
|
||||
fprintf(stderr, "avatar_send failed for friend %d\n", num);
|
||||
}
|
||||
}
|
||||
|
||||
Friends.list[num].connection_status = connection_status;
|
||||
@ -381,8 +392,9 @@ static void friendlist_onConnectionChange(ToxWindow *self, Tox *m, uint32_t num,
|
||||
|
||||
static void friendlist_onNickChange(ToxWindow *self, Tox *m, uint32_t num, const char *nick, size_t length)
|
||||
{
|
||||
if (num >= Friends.max_idx)
|
||||
if (num >= Friends.max_idx) {
|
||||
return;
|
||||
}
|
||||
|
||||
/* save old name for log renaming */
|
||||
char oldname[TOXIC_MAX_NAME_LENGTH + 1];
|
||||
@ -398,24 +410,27 @@ static void friendlist_onNickChange(ToxWindow *self, Tox *m, uint32_t num, const
|
||||
strcpy(newnamecpy, Friends.list[num].name);
|
||||
tox_self_get_address(m, (uint8_t *) myid);
|
||||
|
||||
if (strcmp(oldname, newnamecpy) != 0)
|
||||
if (strcmp(oldname, newnamecpy) != 0) {
|
||||
rename_logfile(oldname, newnamecpy, myid, Friends.list[num].pub_key, Friends.list[num].chatwin);
|
||||
}
|
||||
|
||||
sort_friendlist_index();
|
||||
}
|
||||
|
||||
static void friendlist_onStatusChange(ToxWindow *self, Tox *m, uint32_t num, TOX_USER_STATUS status)
|
||||
{
|
||||
if (num >= Friends.max_idx)
|
||||
if (num >= Friends.max_idx) {
|
||||
return;
|
||||
}
|
||||
|
||||
Friends.list[num].status = status;
|
||||
}
|
||||
|
||||
static void friendlist_onStatusMessageChange(ToxWindow *self, uint32_t num, const char *note, size_t length)
|
||||
{
|
||||
if (length > TOX_MAX_STATUS_MESSAGE_LENGTH || num >= Friends.max_idx)
|
||||
if (length > TOX_MAX_STATUS_MESSAGE_LENGTH || num >= Friends.max_idx) {
|
||||
return;
|
||||
}
|
||||
|
||||
snprintf(Friends.list[num].statusmsg, sizeof(Friends.list[num].statusmsg), "%s", note);
|
||||
Friends.list[num].statusmsg_len = strlen(Friends.list[num].statusmsg);
|
||||
@ -429,8 +444,9 @@ void friendlist_onFriendAdded(ToxWindow *self, Tox *m, uint32_t num, bool sort)
|
||||
uint32_t i;
|
||||
|
||||
for (i = 0; i <= Friends.max_idx; ++i) {
|
||||
if (Friends.list[i].active)
|
||||
if (Friends.list[i].active) {
|
||||
continue;
|
||||
}
|
||||
|
||||
++Friends.num_friends;
|
||||
|
||||
@ -444,14 +460,16 @@ void friendlist_onFriendAdded(ToxWindow *self, Tox *m, uint32_t num, bool sort)
|
||||
TOX_ERR_FRIEND_GET_PUBLIC_KEY pkerr;
|
||||
tox_friend_get_public_key(m, num, (uint8_t *) Friends.list[i].pub_key, &pkerr);
|
||||
|
||||
if (pkerr != TOX_ERR_FRIEND_GET_PUBLIC_KEY_OK)
|
||||
if (pkerr != TOX_ERR_FRIEND_GET_PUBLIC_KEY_OK) {
|
||||
fprintf(stderr, "tox_friend_get_public_key failed (error %d)\n", pkerr);
|
||||
}
|
||||
|
||||
TOX_ERR_FRIEND_GET_LAST_ONLINE loerr;
|
||||
time_t t = tox_friend_get_last_online(m, num, &loerr);
|
||||
|
||||
if (loerr != TOX_ERR_FRIEND_GET_LAST_ONLINE_OK)
|
||||
if (loerr != TOX_ERR_FRIEND_GET_LAST_ONLINE_OK) {
|
||||
t = 0;
|
||||
}
|
||||
|
||||
update_friend_last_online(i, t);
|
||||
|
||||
@ -460,11 +478,13 @@ void friendlist_onFriendAdded(ToxWindow *self, Tox *m, uint32_t num, bool sort)
|
||||
snprintf(Friends.list[i].name, sizeof(Friends.list[i].name), "%s", tempname);
|
||||
Friends.list[i].namelength = strlen(Friends.list[i].name);
|
||||
|
||||
if (i == Friends.max_idx)
|
||||
if (i == Friends.max_idx) {
|
||||
++Friends.max_idx;
|
||||
}
|
||||
|
||||
if (sort)
|
||||
if (sort) {
|
||||
sort_friendlist_index();
|
||||
}
|
||||
|
||||
#ifdef AUDIO
|
||||
init_friend_AV(i);
|
||||
@ -483,8 +503,9 @@ static void friendlist_add_blocked(Tox *m, uint32_t fnum, uint32_t bnum)
|
||||
int i;
|
||||
|
||||
for (i = 0; i <= Friends.max_idx; ++i) {
|
||||
if (Friends.list[i].active)
|
||||
if (Friends.list[i].active) {
|
||||
continue;
|
||||
}
|
||||
|
||||
++Friends.num_friends;
|
||||
|
||||
@ -498,8 +519,9 @@ static void friendlist_add_blocked(Tox *m, uint32_t fnum, uint32_t bnum)
|
||||
memcpy(Friends.list[i].name, Blocked.list[bnum].name, Friends.list[i].namelength + 1);
|
||||
memcpy(Friends.list[i].pub_key, Blocked.list[bnum].pub_key, TOX_PUBLIC_KEY_SIZE);
|
||||
|
||||
if (i == Friends.max_idx)
|
||||
if (i == Friends.max_idx) {
|
||||
++Friends.max_idx;
|
||||
}
|
||||
|
||||
sort_blocklist_index();
|
||||
sort_friendlist_index();
|
||||
@ -511,11 +533,13 @@ static void friendlist_add_blocked(Tox *m, uint32_t fnum, uint32_t bnum)
|
||||
static void friendlist_onFileRecv(ToxWindow *self, Tox *m, uint32_t num, uint32_t filenum,
|
||||
uint64_t file_size, const char *filename, size_t name_length)
|
||||
{
|
||||
if (num >= Friends.max_idx)
|
||||
if (num >= Friends.max_idx) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (Friends.list[num].chatwin != -1)
|
||||
if (Friends.list[num].chatwin != -1) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (get_num_active_windows() < MAX_WINDOWS_NUM) {
|
||||
Friends.list[num].chatwin = add_window(m, new_chat(m, Friends.list[num].num));
|
||||
@ -536,11 +560,13 @@ static void friendlist_onFileRecv(ToxWindow *self, Tox *m, uint32_t num, uint32_
|
||||
static void friendlist_onGroupInvite(ToxWindow *self, Tox *m, int32_t num, uint8_t type, const char *group_pub_key,
|
||||
uint16_t length)
|
||||
{
|
||||
if (num >= Friends.max_idx)
|
||||
if (num >= Friends.max_idx) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (Friends.list[num].chatwin != -1)
|
||||
if (Friends.list[num].chatwin != -1) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (get_num_active_windows() < MAX_WINDOWS_NUM) {
|
||||
Friends.list[num].chatwin = add_window(m, new_chat(m, Friends.list[num].num));
|
||||
@ -559,12 +585,14 @@ static void friendlist_onGroupInvite(ToxWindow *self, Tox *m, int32_t num, uint8
|
||||
/* move friendlist/blocklist cursor up and down */
|
||||
static void select_friend(ToxWindow *self, wint_t key, int *selected, int num)
|
||||
{
|
||||
if (num <= 0)
|
||||
if (num <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (key == KEY_UP) {
|
||||
if (--(*selected) < 0)
|
||||
if (--(*selected) < 0) {
|
||||
*selected = num - 1;
|
||||
}
|
||||
} else if (key == KEY_DOWN) {
|
||||
*selected = (*selected + 1) % num;
|
||||
}
|
||||
@ -581,8 +609,9 @@ static void delete_friend(Tox *m, uint32_t f_num)
|
||||
|
||||
--Friends.num_friends;
|
||||
|
||||
if (Friends.list[f_num].connection_status != TOX_CONNECTION_NONE)
|
||||
if (Friends.list[f_num].connection_status != TOX_CONNECTION_NONE) {
|
||||
--Friends.num_online;
|
||||
}
|
||||
|
||||
/* close friend's chatwindow if it's currently open */
|
||||
if (Friends.list[f_num].chatwin >= 0) {
|
||||
@ -594,16 +623,18 @@ static void delete_friend(Tox *m, uint32_t f_num)
|
||||
}
|
||||
}
|
||||
|
||||
if (Friends.list[f_num].group_invite.key != NULL)
|
||||
if (Friends.list[f_num].group_invite.key != NULL) {
|
||||
free(Friends.list[f_num].group_invite.key);
|
||||
}
|
||||
|
||||
memset(&Friends.list[f_num], 0, sizeof(ToxicFriend));
|
||||
|
||||
int i;
|
||||
|
||||
for (i = Friends.max_idx; i > 0; --i) {
|
||||
if (Friends.list[i - 1].active)
|
||||
if (Friends.list[i - 1].active) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
Friends.max_idx = i;
|
||||
@ -614,8 +645,9 @@ static void delete_friend(Tox *m, uint32_t f_num)
|
||||
#endif
|
||||
|
||||
/* make sure num_selected stays within Friends.num_friends range */
|
||||
if (Friends.num_friends && Friends.num_selected == Friends.num_friends)
|
||||
if (Friends.num_friends && Friends.num_selected == Friends.num_friends) {
|
||||
--Friends.num_selected;
|
||||
}
|
||||
|
||||
store_data(m, DATA_FILE);
|
||||
}
|
||||
@ -651,8 +683,9 @@ static void del_friend_deactivate(ToxWindow *self, Tox *m, wint_t key)
|
||||
|
||||
static void draw_del_popup(void)
|
||||
{
|
||||
if (!PendingDelete.active)
|
||||
if (!PendingDelete.active) {
|
||||
return;
|
||||
}
|
||||
|
||||
wattron(PendingDelete.popup, A_BOLD);
|
||||
box(PendingDelete.popup, ACS_VLINE, ACS_HLINE);
|
||||
@ -664,10 +697,11 @@ static void draw_del_popup(void)
|
||||
|
||||
pthread_mutex_lock(&Winthread.lock);
|
||||
|
||||
if (blocklist_view == 0)
|
||||
if (blocklist_view == 0) {
|
||||
wprintw(PendingDelete.popup, "%s", Friends.list[PendingDelete.num].name);
|
||||
else
|
||||
} else {
|
||||
wprintw(PendingDelete.popup, "%s", Blocked.list[PendingDelete.num].name);
|
||||
}
|
||||
|
||||
pthread_mutex_unlock(&Winthread.lock);
|
||||
|
||||
@ -685,8 +719,9 @@ static void delete_blocked_friend(uint32_t bnum)
|
||||
int i;
|
||||
|
||||
for (i = Blocked.max_idx; i > 0; --i) {
|
||||
if (Blocked.list[i - 1].active)
|
||||
if (Blocked.list[i - 1].active) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
--Blocked.num_blocked;
|
||||
@ -694,15 +729,17 @@ static void delete_blocked_friend(uint32_t bnum)
|
||||
realloc_blocklist(i);
|
||||
save_blocklist(BLOCK_FILE);
|
||||
|
||||
if (Blocked.num_blocked && Blocked.num_selected == Blocked.num_blocked)
|
||||
if (Blocked.num_blocked && Blocked.num_selected == Blocked.num_blocked) {
|
||||
--Blocked.num_selected;
|
||||
}
|
||||
}
|
||||
|
||||
/* deletes contact from friendlist and puts in blocklist */
|
||||
void block_friend(Tox *m, uint32_t fnum)
|
||||
{
|
||||
if (Friends.num_friends <= 0)
|
||||
if (Friends.num_friends <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
realloc_blocklist(Blocked.max_idx + 1);
|
||||
memset(&Blocked.list[Blocked.max_idx], 0, sizeof(BlockedFriend));
|
||||
@ -710,8 +747,9 @@ void block_friend(Tox *m, uint32_t fnum)
|
||||
int i;
|
||||
|
||||
for (i = 0; i <= Blocked.max_idx; ++i) {
|
||||
if (Blocked.list[i].active)
|
||||
if (Blocked.list[i].active) {
|
||||
continue;
|
||||
}
|
||||
|
||||
Blocked.list[i].active = true;
|
||||
Blocked.list[i].num = i;
|
||||
@ -722,8 +760,9 @@ void block_friend(Tox *m, uint32_t fnum)
|
||||
|
||||
++Blocked.num_blocked;
|
||||
|
||||
if (i == Blocked.max_idx)
|
||||
if (i == Blocked.max_idx) {
|
||||
++Blocked.max_idx;
|
||||
}
|
||||
|
||||
delete_friend(m, fnum);
|
||||
save_blocklist(BLOCK_FILE);
|
||||
@ -737,8 +776,9 @@ void block_friend(Tox *m, uint32_t fnum)
|
||||
/* removes friend from blocklist, puts back in friendlist */
|
||||
static void unblock_friend(Tox *m, uint32_t bnum)
|
||||
{
|
||||
if (Blocked.num_blocked <= 0)
|
||||
if (Blocked.num_blocked <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
TOX_ERR_FRIEND_ADD err;
|
||||
uint32_t friendnum = tox_friend_add_norequest(m, (uint8_t *) Blocked.list[bnum].pub_key, &err);
|
||||
@ -767,34 +807,40 @@ static void friendlist_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
|
||||
return;
|
||||
}
|
||||
|
||||
if (!blocklist_view && !Friends.num_friends && (key != KEY_RIGHT && key != KEY_LEFT))
|
||||
if (!blocklist_view && !Friends.num_friends && (key != KEY_RIGHT && key != KEY_LEFT)) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (blocklist_view && !Blocked.num_blocked && (key != KEY_RIGHT && key != KEY_LEFT))
|
||||
if (blocklist_view && !Blocked.num_blocked && (key != KEY_RIGHT && key != KEY_LEFT)) {
|
||||
return;
|
||||
}
|
||||
|
||||
int f = 0;
|
||||
|
||||
if (blocklist_view == 1 && Blocked.num_blocked)
|
||||
if (blocklist_view == 1 && Blocked.num_blocked) {
|
||||
f = Blocked.index[Blocked.num_selected];
|
||||
else if (Friends.num_friends)
|
||||
} else if (Friends.num_friends) {
|
||||
f = Friends.index[Friends.num_selected];
|
||||
}
|
||||
|
||||
/* lock screen and force decision on deletion popup */
|
||||
if (PendingDelete.active) {
|
||||
if (key == 'y' || key == 'n')
|
||||
if (key == 'y' || key == 'n') {
|
||||
del_friend_deactivate(self, m, key);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if (key == ltr)
|
||||
if (key == ltr) {
|
||||
return;
|
||||
}
|
||||
|
||||
switch (key) {
|
||||
case '\r':
|
||||
if (blocklist_view)
|
||||
if (blocklist_view) {
|
||||
break;
|
||||
}
|
||||
|
||||
/* Jump to chat window if already open */
|
||||
if (Friends.list[f].chatwin != -1) {
|
||||
@ -815,10 +861,11 @@ static void friendlist_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
|
||||
break;
|
||||
|
||||
case 'b':
|
||||
if (!blocklist_view)
|
||||
if (!blocklist_view) {
|
||||
block_friend(m, f);
|
||||
else
|
||||
} else {
|
||||
unblock_friend(m, f);
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
@ -828,10 +875,11 @@ static void friendlist_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
|
||||
break;
|
||||
|
||||
default:
|
||||
if (blocklist_view == 0)
|
||||
if (blocklist_view == 0) {
|
||||
select_friend(self, key, &Friends.num_selected, Friends.num_friends);
|
||||
else
|
||||
} else {
|
||||
select_friend(self, key, &Blocked.num_selected, Blocked.num_blocked);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
@ -846,8 +894,9 @@ static void blocklist_onDraw(ToxWindow *self, Tox *m, int y2, int x2)
|
||||
wattroff(self->window, A_BOLD);
|
||||
wprintw(self->window, "%d\n\n", Blocked.num_blocked);
|
||||
|
||||
if ((y2 - FLIST_OFST) <= 0)
|
||||
if ((y2 - FLIST_OFST) <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
uint32_t selected_num = 0;
|
||||
|
||||
@ -876,15 +925,17 @@ static void blocklist_onDraw(ToxWindow *self, Tox *m, int y2, int x2)
|
||||
wprintw(self->window, "x");
|
||||
wattroff(self->window, COLOR_PAIR(RED));
|
||||
|
||||
if (f_selected)
|
||||
if (f_selected) {
|
||||
wattron(self->window, COLOR_PAIR(BLUE));
|
||||
}
|
||||
|
||||
wattron(self->window, A_BOLD);
|
||||
wprintw(self->window, " %s\n", Blocked.list[f].name);
|
||||
wattroff(self->window, A_BOLD);
|
||||
|
||||
if (f_selected)
|
||||
if (f_selected) {
|
||||
wattroff(self->window, COLOR_PAIR(BLUE));
|
||||
}
|
||||
}
|
||||
|
||||
wprintw(self->window, "\n");
|
||||
@ -899,15 +950,17 @@ static void blocklist_onDraw(ToxWindow *self, Tox *m, int y2, int x2)
|
||||
|
||||
int i;
|
||||
|
||||
for (i = 0; i < TOX_PUBLIC_KEY_SIZE; ++i)
|
||||
for (i = 0; i < TOX_PUBLIC_KEY_SIZE; ++i) {
|
||||
wprintw(self->window, "%02X", Blocked.list[selected_num].pub_key[i] & 0xff);
|
||||
}
|
||||
}
|
||||
|
||||
wnoutrefresh(self->window);
|
||||
draw_del_popup();
|
||||
|
||||
if (self->help->active)
|
||||
if (self->help->active) {
|
||||
help_onDraw(self);
|
||||
}
|
||||
}
|
||||
|
||||
static void friendlist_onDraw(ToxWindow *self, Tox *m)
|
||||
@ -941,8 +994,9 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
|
||||
|
||||
wprintw(self->window, "%d/%d \n\n", Friends.num_online, Friends.num_friends);
|
||||
|
||||
if ((y2 - FLIST_OFST) <= 0)
|
||||
if ((y2 - FLIST_OFST) <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
uint32_t selected_num = 0;
|
||||
|
||||
@ -1006,8 +1060,9 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
|
||||
wprintw(self->window, "%s ", ONLINE_CHAR);
|
||||
wattroff(self->window, COLOR_PAIR(colour) | A_BOLD);
|
||||
|
||||
if (f_selected)
|
||||
if (f_selected) {
|
||||
wattron(self->window, COLOR_PAIR(BLUE));
|
||||
}
|
||||
|
||||
wattron(self->window, A_BOLD);
|
||||
pthread_mutex_lock(&Winthread.lock);
|
||||
@ -1015,8 +1070,9 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
|
||||
pthread_mutex_unlock(&Winthread.lock);
|
||||
wattroff(self->window, A_BOLD);
|
||||
|
||||
if (f_selected)
|
||||
if (f_selected) {
|
||||
wattroff(self->window, COLOR_PAIR(BLUE));
|
||||
}
|
||||
|
||||
/* Reset Friends.list[f].statusmsg on window resize */
|
||||
if (fix_statuses) {
|
||||
@ -1049,8 +1105,9 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
|
||||
Friends.list[f].statusmsg_len = maxlen;
|
||||
}
|
||||
|
||||
if (Friends.list[f].statusmsg_len > 0)
|
||||
if (Friends.list[f].statusmsg_len > 0) {
|
||||
wprintw(self->window, " %s", Friends.list[f].statusmsg);
|
||||
}
|
||||
|
||||
pthread_mutex_unlock(&Winthread.lock);
|
||||
|
||||
@ -1058,8 +1115,9 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
|
||||
} else {
|
||||
wprintw(self->window, "%s ", OFFLINE_CHAR);
|
||||
|
||||
if (f_selected)
|
||||
if (f_selected) {
|
||||
wattron(self->window, COLOR_PAIR(BLUE));
|
||||
}
|
||||
|
||||
wattron(self->window, A_BOLD);
|
||||
pthread_mutex_lock(&Winthread.lock);
|
||||
@ -1067,8 +1125,9 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
|
||||
pthread_mutex_unlock(&Winthread.lock);
|
||||
wattroff(self->window, A_BOLD);
|
||||
|
||||
if (f_selected)
|
||||
if (f_selected) {
|
||||
wattroff(self->window, COLOR_PAIR(BLUE));
|
||||
}
|
||||
|
||||
pthread_mutex_lock(&Winthread.lock);
|
||||
time_t last_seen = Friends.list[f].last_online.last_on;
|
||||
@ -1116,15 +1175,17 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
|
||||
|
||||
int i;
|
||||
|
||||
for (i = 0; i < TOX_PUBLIC_KEY_SIZE; ++i)
|
||||
for (i = 0; i < TOX_PUBLIC_KEY_SIZE; ++i) {
|
||||
wprintw(self->window, "%02X", Friends.list[selected_num].pub_key[i] & 0xff);
|
||||
}
|
||||
}
|
||||
|
||||
wnoutrefresh(self->window);
|
||||
draw_del_popup();
|
||||
|
||||
if (self->help->active)
|
||||
if (self->help->active) {
|
||||
help_onDraw(self);
|
||||
}
|
||||
}
|
||||
|
||||
void disable_chatwin(uint32_t f_num)
|
||||
@ -1137,8 +1198,9 @@ static void friendlist_onAV(ToxWindow *self, ToxAV *av, uint32_t friend_number,
|
||||
{
|
||||
assert(0);
|
||||
|
||||
if ( friend_number >= Friends.max_idx)
|
||||
if (friend_number >= Friends.max_idx) {
|
||||
return;
|
||||
}
|
||||
|
||||
assert(0);
|
||||
Tox *m = toxav_get_tox(av);
|
||||
@ -1214,8 +1276,9 @@ ToxWindow new_friendlist(void)
|
||||
|
||||
Help *help = calloc(1, sizeof(Help));
|
||||
|
||||
if (help == NULL)
|
||||
if (help == NULL) {
|
||||
exit_toxic_err("failed in new_friendlist", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
ret.help = help;
|
||||
strcpy(ret.name, "contacts");
|
||||
|
@ -79,8 +79,9 @@ void cmd_accept(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
|
||||
int i;
|
||||
|
||||
for (i = FrndRequests.max_idx; i > 0; --i) {
|
||||
if (FrndRequests.request[i - 1].active)
|
||||
if (FrndRequests.request[i - 1].active) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
FrndRequests.max_idx = i;
|
||||
@ -313,8 +314,9 @@ void cmd_decline(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)
|
||||
int i;
|
||||
|
||||
for (i = FrndRequests.max_idx; i > 0; --i) {
|
||||
if (FrndRequests.request[i - 1].active)
|
||||
if (FrndRequests.request[i - 1].active) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
FrndRequests.max_idx = i;
|
||||
@ -335,11 +337,11 @@ void cmd_groupchat(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*arg
|
||||
|
||||
uint8_t type;
|
||||
|
||||
if (!strcasecmp(argv[1], "audio"))
|
||||
if (!strcasecmp(argv[1], "audio")) {
|
||||
type = TOX_CONFERENCE_TYPE_AV;
|
||||
else if (!strcasecmp(argv[1], "text"))
|
||||
} else if (!strcasecmp(argv[1], "text")) {
|
||||
type = TOX_CONFERENCE_TYPE_TEXT;
|
||||
else {
|
||||
} else {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Valid group types are: text | audio");
|
||||
return;
|
||||
}
|
||||
@ -373,10 +375,11 @@ void cmd_log(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX
|
||||
struct chatlog *log = self->chatwin->log;
|
||||
|
||||
if (argc == 0) {
|
||||
if (log->log_on)
|
||||
if (log->log_on) {
|
||||
msg = "Logging for this window is ON; type \"/log off\" to disable. (Logs are not encrypted)";
|
||||
else
|
||||
} else {
|
||||
msg = "Logging for this window is OFF; type \"/log on\" to enable.";
|
||||
}
|
||||
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, msg);
|
||||
return;
|
||||
@ -403,8 +406,9 @@ void cmd_log(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, msg);
|
||||
return;
|
||||
} else if (!strcmp(swch, "0") || !strcmp(swch, "off")) {
|
||||
if (self->is_chat)
|
||||
if (self->is_chat) {
|
||||
Friends.list[self->num].logging_on = false;
|
||||
}
|
||||
|
||||
log_disable(log);
|
||||
|
||||
@ -592,8 +596,9 @@ void cmd_requests(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv
|
||||
int count = 0;
|
||||
|
||||
for (i = 0; i < FrndRequests.max_idx; ++i) {
|
||||
if (!FrndRequests.request[i].active)
|
||||
if (!FrndRequests.request[i].active) {
|
||||
continue;
|
||||
}
|
||||
|
||||
char id[TOX_PUBLIC_KEY_SIZE * 2 + 1] = {0};
|
||||
|
||||
@ -606,8 +611,9 @@ void cmd_requests(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%d : %s", i, id);
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%s", FrndRequests.request[i].msg);
|
||||
|
||||
if (++count < FrndRequests.num_requests)
|
||||
if (++count < FrndRequests.num_requests) {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -616,7 +622,7 @@ void cmd_status(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
|
||||
bool have_note = false;
|
||||
const char *errmsg;
|
||||
|
||||
lock_status ();
|
||||
lock_status();
|
||||
|
||||
if (argc >= 2) {
|
||||
have_note = true;
|
||||
@ -629,13 +635,13 @@ void cmd_status(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
|
||||
const char *status_str = argv[1];
|
||||
TOX_USER_STATUS status;
|
||||
|
||||
if (!strcasecmp(status_str, "online"))
|
||||
if (!strcasecmp(status_str, "online")) {
|
||||
status = TOX_USER_STATUS_NONE;
|
||||
else if (!strcasecmp(status_str, "away"))
|
||||
} else if (!strcasecmp(status_str, "away")) {
|
||||
status = TOX_USER_STATUS_AWAY;
|
||||
else if (!strcasecmp(status_str, "busy"))
|
||||
} else if (!strcasecmp(status_str, "busy")) {
|
||||
status = TOX_USER_STATUS_BUSY;
|
||||
else {
|
||||
} else {
|
||||
errmsg = "Invalid status. Valid statuses are: online, busy and away.";
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, errmsg);
|
||||
goto finish;
|
||||
@ -663,5 +669,5 @@ void cmd_status(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
|
||||
}
|
||||
|
||||
finish:
|
||||
unlock_status ();
|
||||
unlock_status();
|
||||
}
|
||||
|
@ -132,8 +132,9 @@ int init_groupchat_win(ToxWindow *prompt, Tox *m, uint32_t groupnum, uint8_t typ
|
||||
|
||||
set_active_window(groupchats[i].chatwin);
|
||||
|
||||
if (i == max_groupchat_index)
|
||||
if (i == max_groupchat_index) {
|
||||
++max_groupchat_index;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -166,8 +167,9 @@ void free_groupchat(ToxWindow *self, Tox *m, uint32_t groupnum)
|
||||
int i;
|
||||
|
||||
for (i = max_groupchat_index; i > 0; --i) {
|
||||
if (groupchats[i - 1].active)
|
||||
if (groupchats[i - 1].active) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
max_groupchat_index = i;
|
||||
@ -193,8 +195,9 @@ void redraw_groupchat_win(ToxWindow *self)
|
||||
getmaxyx(stdscr, y2, x2);
|
||||
y2 -= 2;
|
||||
|
||||
if (y2 <= 0 || x2 <= 0)
|
||||
if (y2 <= 0 || x2 <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (ctx->sidebar) {
|
||||
delwin(ctx->sidebar);
|
||||
@ -222,8 +225,9 @@ void redraw_groupchat_win(ToxWindow *self)
|
||||
static void groupchat_onGroupMessage(ToxWindow *self, Tox *m, uint32_t groupnum, uint32_t peernum,
|
||||
TOX_MESSAGE_TYPE type, const char *msg, size_t len)
|
||||
{
|
||||
if (self->num != groupnum)
|
||||
if (self->num != groupnum) {
|
||||
return;
|
||||
}
|
||||
|
||||
ChatContext *ctx = self->chatwin;
|
||||
|
||||
@ -242,10 +246,11 @@ static void groupchat_onGroupMessage(ToxWindow *self, Tox *m, uint32_t groupnum,
|
||||
if (strcasestr(msg, selfnick) && strcmp(selfnick, nick)) {
|
||||
sound_notify(self, generic_message, NT_WNDALERT_0 | user_settings->bell_on_message, NULL);
|
||||
|
||||
if (self->active_box != -1)
|
||||
if (self->active_box != -1) {
|
||||
box_silent_notify2(self, NT_NOFOCUS, self->active_box, "%s %s", nick, msg);
|
||||
else
|
||||
} else {
|
||||
box_silent_notify(self, NT_NOFOCUS, &self->active_box, self->name, "%s %s", nick, msg);
|
||||
}
|
||||
|
||||
nick_clr = RED;
|
||||
} else {
|
||||
@ -265,8 +270,9 @@ static void groupchat_onGroupTitleChange(ToxWindow *self, Tox *m, uint32_t group
|
||||
{
|
||||
ChatContext *ctx = self->chatwin;
|
||||
|
||||
if (self->num != groupnum)
|
||||
if (self->num != groupnum) {
|
||||
return;
|
||||
}
|
||||
|
||||
set_window_title(self, title, length);
|
||||
|
||||
@ -274,8 +280,9 @@ static void groupchat_onGroupTitleChange(ToxWindow *self, Tox *m, uint32_t group
|
||||
get_time_str(timefrmt, sizeof(timefrmt));
|
||||
|
||||
/* don't announce title when we join the room */
|
||||
if (!timed_out(groupchats[self->num].start_time, GROUP_EVENT_WAIT))
|
||||
if (!timed_out(groupchats[self->num].start_time, GROUP_EVENT_WAIT)) {
|
||||
return;
|
||||
}
|
||||
|
||||
char nick[TOX_MAX_NAME_LENGTH];
|
||||
get_group_nick_truncate(m, nick, peernum, groupnum);
|
||||
@ -383,11 +390,13 @@ static void update_peer_list(Tox *m, uint32_t groupnum, uint32_t num_peers)
|
||||
|
||||
static void groupchat_onGroupNameListChange(ToxWindow *self, Tox *m, uint32_t groupnum)
|
||||
{
|
||||
if (self->num != groupnum)
|
||||
if (self->num != groupnum) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (groupnum > max_groupchat_index)
|
||||
if (groupnum > max_groupchat_index) {
|
||||
return;
|
||||
}
|
||||
|
||||
GroupChat *chat = &groupchats[groupnum];
|
||||
TOX_ERR_CONFERENCE_PEER_QUERY err;
|
||||
@ -464,27 +473,31 @@ static void groupchat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
|
||||
getyx(self->window, y, x);
|
||||
getmaxyx(self->window, y2, x2);
|
||||
|
||||
if (x2 <= 0 || y2 <= 0)
|
||||
if (x2 <= 0 || y2 <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (self->help->active) {
|
||||
help_onKey(self, key);
|
||||
return;
|
||||
}
|
||||
|
||||
if (ctx->pastemode && key == '\r')
|
||||
if (ctx->pastemode && key == '\r') {
|
||||
key = '\n';
|
||||
}
|
||||
|
||||
if (ltr || key == '\n') { /* char is printable */
|
||||
input_new_char(self, key, x, y, x2, y2);
|
||||
return;
|
||||
}
|
||||
|
||||
if (line_info_onKey(self, key))
|
||||
if (line_info_onKey(self, key)) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (input_handle(self, key, x, y, x2, y2))
|
||||
if (input_handle(self, key, x, y, x2, y2)) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (key == '\t') { /* TAB key: auto-completes peer name or command */
|
||||
if (ctx->len > 0) {
|
||||
@ -523,11 +536,13 @@ static void groupchat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
|
||||
} else if (key == user_settings->key_peer_list_down) { /* Scroll peerlist up and down one position */
|
||||
int L = y2 - CHATBOX_HEIGHT - SDBAR_OFST;
|
||||
|
||||
if (groupchats[self->num].side_pos < groupchats[self->num].num_peers - L)
|
||||
if (groupchats[self->num].side_pos < groupchats[self->num].num_peers - L) {
|
||||
++groupchats[self->num].side_pos;
|
||||
}
|
||||
} else if (key == user_settings->key_peer_list_up) {
|
||||
if (groupchats[self->num].side_pos > 0)
|
||||
if (groupchats[self->num].side_pos > 0) {
|
||||
--groupchats[self->num].side_pos;
|
||||
}
|
||||
} else if (key == '\r') {
|
||||
rm_trailing_spaces_buf(ctx);
|
||||
|
||||
@ -538,8 +553,9 @@ static void groupchat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
|
||||
|
||||
char line[MAX_STR_SIZE];
|
||||
|
||||
if (wcs_to_mbs_buf(line, ctx->line, MAX_STR_SIZE) == -1)
|
||||
if (wcs_to_mbs_buf(line, ctx->line, MAX_STR_SIZE) == -1) {
|
||||
memset(&line, 0, sizeof(line));
|
||||
}
|
||||
|
||||
if (line[0] == '/') {
|
||||
if (strcmp(line, "/close") == 0) {
|
||||
@ -570,8 +586,9 @@ static void groupchat_onDraw(ToxWindow *self, Tox *m)
|
||||
int x2, y2;
|
||||
getmaxyx(self->window, y2, x2);
|
||||
|
||||
if (x2 <= 0 || y2 <= 0)
|
||||
if (x2 <= 0 || y2 <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
ChatContext *ctx = self->chatwin;
|
||||
|
||||
@ -583,8 +600,9 @@ static void groupchat_onDraw(ToxWindow *self, Tox *m)
|
||||
|
||||
curs_set(1);
|
||||
|
||||
if (ctx->len > 0)
|
||||
if (ctx->len > 0) {
|
||||
mvwprintw(ctx->linewin, 1, 0, "%ls", &ctx->line[ctx->start]);
|
||||
}
|
||||
|
||||
wclear(ctx->sidebar);
|
||||
mvwhline(self->window, y2 - CHATBOX_HEIGHT, 0, ACS_HLINE, x2);
|
||||
@ -637,8 +655,9 @@ static void groupchat_onDraw(ToxWindow *self, Tox *m)
|
||||
|
||||
wnoutrefresh(self->window);
|
||||
|
||||
if (self->help->active)
|
||||
if (self->help->active) {
|
||||
help_onDraw(self);
|
||||
}
|
||||
}
|
||||
|
||||
static void groupchat_onInit(ToxWindow *self, Tox *m)
|
||||
@ -646,8 +665,9 @@ static void groupchat_onInit(ToxWindow *self, Tox *m)
|
||||
int x2, y2;
|
||||
getmaxyx(self->window, y2, x2);
|
||||
|
||||
if (x2 <= 0 || y2 <= 0)
|
||||
if (x2 <= 0 || y2 <= 0) {
|
||||
exit_toxic_err("failed in groupchat_onInit", FATALERR_CURSES);
|
||||
}
|
||||
|
||||
ChatContext *ctx = self->chatwin;
|
||||
|
||||
@ -658,8 +678,9 @@ static void groupchat_onInit(ToxWindow *self, Tox *m)
|
||||
ctx->hst = calloc(1, sizeof(struct history));
|
||||
ctx->log = calloc(1, sizeof(struct chatlog));
|
||||
|
||||
if (ctx->log == NULL || ctx->hst == NULL)
|
||||
if (ctx->log == NULL || ctx->hst == NULL) {
|
||||
exit_toxic_err("failed in groupchat_onInit", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
line_info_init(ctx->hst);
|
||||
|
||||
@ -667,8 +688,9 @@ static void groupchat_onInit(ToxWindow *self, Tox *m)
|
||||
char myid[TOX_ADDRESS_SIZE];
|
||||
tox_self_get_address(m, (uint8_t *) myid);
|
||||
|
||||
if (log_enable(self->name, myid, NULL, ctx->log, LOG_GROUP) == -1)
|
||||
if (log_enable(self->name, myid, NULL, ctx->log, LOG_GROUP) == -1) {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Warning: Log failed to initialize.");
|
||||
}
|
||||
}
|
||||
|
||||
execute(ctx->history, self, m, "/log", GLOBAL_COMMAND_MODE);
|
||||
@ -698,8 +720,9 @@ ToxWindow new_group_chat(Tox *m, uint32_t groupnum)
|
||||
ChatContext *chatwin = calloc(1, sizeof(ChatContext));
|
||||
Help *help = calloc(1, sizeof(Help));
|
||||
|
||||
if (chatwin == NULL || help == NULL)
|
||||
if (chatwin == NULL || help == NULL) {
|
||||
exit_toxic_err("failed in new_group_chat", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
ret.chatwin = chatwin;
|
||||
ret.help = help;
|
||||
|
12
src/help.c
12
src/help.c
@ -40,14 +40,16 @@
|
||||
|
||||
void help_init_menu(ToxWindow *self)
|
||||
{
|
||||
if (self->help->win)
|
||||
if (self->help->win) {
|
||||
delwin(self->help->win);
|
||||
}
|
||||
|
||||
int y2, x2;
|
||||
getmaxyx(self->window, y2, x2);
|
||||
|
||||
if (y2 < HELP_MENU_HEIGHT || x2 < HELP_MENU_WIDTH)
|
||||
if (y2 < HELP_MENU_HEIGHT || x2 < HELP_MENU_WIDTH) {
|
||||
return;
|
||||
}
|
||||
|
||||
self->help->win = newwin(HELP_MENU_HEIGHT, HELP_MENU_WIDTH, 3, 3);
|
||||
self->help->active = true;
|
||||
@ -62,14 +64,16 @@ static void help_exit(ToxWindow *self)
|
||||
|
||||
static void help_init_window(ToxWindow *self, int height, int width)
|
||||
{
|
||||
if (self->help->win)
|
||||
if (self->help->win) {
|
||||
delwin(self->help->win);
|
||||
}
|
||||
|
||||
int y2, x2;
|
||||
getmaxyx(stdscr, y2, x2);
|
||||
|
||||
if (y2 <= 0 || x2 <= 0)
|
||||
if (y2 <= 0 || x2 <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
height = MIN(height, y2);
|
||||
width = MIN(width, x2);
|
||||
|
31
src/input.c
31
src/input.c
@ -43,8 +43,9 @@ void input_new_char(ToxWindow *self, wint_t key, int x, int y, int mx_x, int mx_
|
||||
ChatContext *ctx = self->chatwin;
|
||||
|
||||
/* this is the only place we need to do this check */
|
||||
if (key == '\n')
|
||||
if (key == '\n') {
|
||||
key = L'¶';
|
||||
}
|
||||
|
||||
int cur_len = wcwidth(key);
|
||||
|
||||
@ -77,17 +78,19 @@ static void input_backspace(ToxWindow *self, int x, int mx_x)
|
||||
int cur_len = ctx->pos > 0 ? wcwidth(ctx->line[ctx->pos - 1]) : 0;
|
||||
int s_len = ctx->start > 0 ? wcwidth(ctx->line[ctx->start - 1]) : 0;
|
||||
|
||||
if (ctx->start && (x >= mx_x - cur_len))
|
||||
if (ctx->start && (x >= mx_x - cur_len)) {
|
||||
ctx->start = MAX(0, ctx->start - 1 + (s_len - cur_len));
|
||||
else if (ctx->start)
|
||||
} else if (ctx->start) {
|
||||
ctx->start = MAX(0, ctx->start - cur_len);
|
||||
}
|
||||
}
|
||||
|
||||
/* delete a char via delete key from input field and buffer */
|
||||
static void input_delete(ToxWindow *self)
|
||||
{
|
||||
if (del_char_buf_frnt(self->chatwin) == -1)
|
||||
if (del_char_buf_frnt(self->chatwin) == -1) {
|
||||
sound_notify(self, notif_error, 0, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
/* delete last typed word */
|
||||
@ -104,15 +107,17 @@ static void input_del_word(ToxWindow *self, int x, int mx_x)
|
||||
/* deletes entire line before cursor from input field and buffer */
|
||||
static void input_discard(ToxWindow *self)
|
||||
{
|
||||
if (discard_buf(self->chatwin) == -1)
|
||||
if (discard_buf(self->chatwin) == -1) {
|
||||
sound_notify(self, notif_error, 0, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
/* deletes entire line after cursor from input field and buffer */
|
||||
static void input_kill(ChatContext *ctx)
|
||||
{
|
||||
if (kill_buf(ctx) == -1)
|
||||
if (kill_buf(ctx) == -1) {
|
||||
sound_notify(NULL, notif_error, NT_ALWAYS, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
static void input_yank(ToxWindow *self, int x, int mx_x)
|
||||
@ -149,8 +154,9 @@ static void input_mv_home(ToxWindow *self)
|
||||
{
|
||||
ChatContext *ctx = self->chatwin;
|
||||
|
||||
if (ctx->pos <= 0)
|
||||
if (ctx->pos <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
ctx->pos = 0;
|
||||
ctx->start = 0;
|
||||
@ -161,18 +167,20 @@ static void input_mv_left(ToxWindow *self, int x, int mx_x)
|
||||
{
|
||||
ChatContext *ctx = self->chatwin;
|
||||
|
||||
if (ctx->pos <= 0)
|
||||
if (ctx->pos <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
int cur_len = ctx->pos > 0 ? wcwidth(ctx->line[ctx->pos - 1]) : 0;
|
||||
int s_len = ctx->start > 0 ? wcwidth(ctx->line[ctx->start - 1]) : 0;
|
||||
|
||||
--ctx->pos;
|
||||
|
||||
if (ctx->start && (x >= mx_x - cur_len))
|
||||
if (ctx->start && (x >= mx_x - cur_len)) {
|
||||
ctx->start = MAX(0, ctx->start - 1 + (s_len - cur_len));
|
||||
else if (ctx->start)
|
||||
} else if (ctx->start) {
|
||||
ctx->start = MAX(0, ctx->start - cur_len);
|
||||
}
|
||||
}
|
||||
|
||||
/* moves cursor/line position right in input field and buffer */
|
||||
@ -180,8 +188,9 @@ static void input_mv_right(ToxWindow *self, int x, int mx_x)
|
||||
{
|
||||
ChatContext *ctx = self->chatwin;
|
||||
|
||||
if (ctx->pos >= ctx->len)
|
||||
if (ctx->pos >= ctx->len) {
|
||||
return;
|
||||
}
|
||||
|
||||
++ctx->pos;
|
||||
|
||||
|
105
src/line_info.c
105
src/line_info.c
@ -40,8 +40,9 @@ void line_info_init(struct history *hst)
|
||||
{
|
||||
hst->line_root = calloc(1, sizeof(struct line_info));
|
||||
|
||||
if (hst->line_root == NULL)
|
||||
if (hst->line_root == NULL) {
|
||||
exit_toxic_err("failed in line_info_init", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
hst->line_start = hst->line_root;
|
||||
hst->line_end = hst->line_start;
|
||||
@ -53,8 +54,9 @@ void line_info_reset_start(ToxWindow *self, struct history *hst)
|
||||
{
|
||||
struct line_info *line = hst->line_end;
|
||||
|
||||
if (line->prev == NULL)
|
||||
if (line->prev == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
int y2, x2;
|
||||
getmaxyx(self->window, y2, x2);
|
||||
@ -88,8 +90,9 @@ void line_info_cleanup(struct history *hst)
|
||||
int i;
|
||||
|
||||
for (i = 0; i < hst->queue_sz; ++i) {
|
||||
if (hst->queue[i])
|
||||
if (hst->queue[i]) {
|
||||
free(hst->queue[i]);
|
||||
}
|
||||
}
|
||||
|
||||
free(hst);
|
||||
@ -114,15 +117,17 @@ static void line_info_root_fwd(struct history *hst)
|
||||
/* returns ptr to queue item 0 and removes it from queue. Returns NULL if queue is empty. */
|
||||
static struct line_info *line_info_ret_queue(struct history *hst)
|
||||
{
|
||||
if (hst->queue_sz <= 0)
|
||||
if (hst->queue_sz <= 0) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
struct line_info *line = hst->queue[0];
|
||||
|
||||
int i;
|
||||
|
||||
for (i = 0; i < hst->queue_sz; ++i)
|
||||
for (i = 0; i < hst->queue_sz; ++i) {
|
||||
hst->queue[i] = hst->queue[i + 1];
|
||||
}
|
||||
|
||||
--hst->queue_sz;
|
||||
|
||||
@ -137,18 +142,21 @@ static struct line_info *line_info_ret_queue(struct history *hst)
|
||||
int line_info_add(ToxWindow *self, const char *timestr, const char *name1, const char *name2, uint8_t type,
|
||||
uint8_t bold, uint8_t colour, const char *msg, ...)
|
||||
{
|
||||
if (!self)
|
||||
if (!self) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
struct history *hst = self->chatwin->hst;
|
||||
|
||||
if (hst->queue_sz >= MAX_LINE_INFO_QUEUE)
|
||||
if (hst->queue_sz >= MAX_LINE_INFO_QUEUE) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
struct line_info *new_line = calloc(1, sizeof(struct line_info));
|
||||
|
||||
if (new_line == NULL)
|
||||
if (new_line == NULL) {
|
||||
exit_toxic_err("failed in line_info_add", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
char frmt_msg[MAX_LINE_INFO_MSG_SIZE] = {0};
|
||||
|
||||
@ -206,8 +214,9 @@ int line_info_add(ToxWindow *self, const char *timestr, const char *name1, const
|
||||
int i;
|
||||
|
||||
for (i = 0; frmt_msg[i]; ++i) {
|
||||
if (frmt_msg[i] == '\n')
|
||||
if (frmt_msg[i] == '\n') {
|
||||
++new_line->newlines;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -245,11 +254,13 @@ static void line_info_check_queue(ToxWindow *self)
|
||||
struct history *hst = self->chatwin->hst;
|
||||
struct line_info *line = line_info_ret_queue(hst);
|
||||
|
||||
if (line == NULL)
|
||||
if (line == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (hst->start_id > user_settings->history_size)
|
||||
if (hst->start_id > user_settings->history_size) {
|
||||
line_info_root_fwd(hst);
|
||||
}
|
||||
|
||||
line->prev = hst->line_end;
|
||||
hst->line_end->next = line;
|
||||
@ -261,8 +272,9 @@ static void line_info_check_queue(ToxWindow *self)
|
||||
getyx(self->chatwin->history, y, x);
|
||||
(void) x;
|
||||
|
||||
if (x2 <= SIDEBAR_WIDTH)
|
||||
if (x2 <= SIDEBAR_WIDTH) {
|
||||
return;
|
||||
}
|
||||
|
||||
int offst = self->show_peerlist ? SIDEBAR_WIDTH : 0; /* offset width of groupchat sidebar */
|
||||
int lines = 1 + line->newlines + (line->len / (x2 - offst));
|
||||
@ -284,8 +296,9 @@ void line_info_print(ToxWindow *self)
|
||||
{
|
||||
ChatContext *ctx = self->chatwin;
|
||||
|
||||
if (ctx == NULL)
|
||||
if (ctx == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
struct history *hst = ctx->hst;
|
||||
|
||||
@ -293,19 +306,25 @@ void line_info_print(ToxWindow *self)
|
||||
line_info_check_queue(self);
|
||||
|
||||
WINDOW *win = ctx->history;
|
||||
|
||||
wclear(win);
|
||||
|
||||
int y2, x2;
|
||||
|
||||
getmaxyx(self->window, y2, x2);
|
||||
|
||||
if (x2 <= SIDEBAR_WIDTH)
|
||||
if (x2 <= SIDEBAR_WIDTH) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (self->is_groupchat)
|
||||
if (self->is_groupchat) {
|
||||
wmove(win, 0, 0);
|
||||
else
|
||||
} else {
|
||||
wmove(win, 2, 0);
|
||||
}
|
||||
|
||||
struct line_info *line = hst->line_start->next;
|
||||
|
||||
int numlines = 0;
|
||||
|
||||
while (line && numlines++ <= y2) {
|
||||
@ -325,10 +344,11 @@ void line_info_print(ToxWindow *self)
|
||||
|
||||
int nameclr = GREEN;
|
||||
|
||||
if (line->colour)
|
||||
if (line->colour) {
|
||||
nameclr = line->colour;
|
||||
else if (type == IN_MSG)
|
||||
} else if (type == IN_MSG) {
|
||||
nameclr = CYAN;
|
||||
}
|
||||
|
||||
wattron(win, COLOR_PAIR(nameclr));
|
||||
wprintw(win, "%s %s: ", user_settings->line_normal, line->name1);
|
||||
@ -339,21 +359,24 @@ void line_info_print(ToxWindow *self)
|
||||
while (msg) {
|
||||
char *line = strsep(&msg, "\n");
|
||||
|
||||
if (line[0] == '>')
|
||||
if (line[0] == '>') {
|
||||
wattron(win, COLOR_PAIR(GREEN));
|
||||
else if (line[0] == '<')
|
||||
} else if (line[0] == '<') {
|
||||
wattron(win, COLOR_PAIR(RED));
|
||||
}
|
||||
|
||||
wprintw(win, "%s%c", line, msg ? '\n' : '\0');
|
||||
|
||||
if (line[0] == '>')
|
||||
if (line[0] == '>') {
|
||||
wattroff(win, COLOR_PAIR(GREEN));
|
||||
else if (line[0] == '<')
|
||||
} else if (line[0] == '<') {
|
||||
wattroff(win, COLOR_PAIR(RED));
|
||||
}
|
||||
|
||||
// change the \0 set by strsep back to \n
|
||||
if (msg)
|
||||
if (msg) {
|
||||
msg[-1] = '\n';
|
||||
}
|
||||
}
|
||||
|
||||
if (type == OUT_MSG && timed_out(line->timestamp, NOREAD_FLAG_TIMEOUT)) {
|
||||
@ -406,19 +429,23 @@ void line_info_print(ToxWindow *self)
|
||||
wattroff(win, COLOR_PAIR(BLUE));
|
||||
}
|
||||
|
||||
if (line->bold)
|
||||
if (line->bold) {
|
||||
wattron(win, A_BOLD);
|
||||
}
|
||||
|
||||
if (line->colour)
|
||||
if (line->colour) {
|
||||
wattron(win, COLOR_PAIR(line->colour));
|
||||
}
|
||||
|
||||
wprintw(win, "%s\n", line->msg);
|
||||
|
||||
if (line->bold)
|
||||
if (line->bold) {
|
||||
wattroff(win, A_BOLD);
|
||||
}
|
||||
|
||||
if (line->colour)
|
||||
if (line->colour) {
|
||||
wattroff(win, COLOR_PAIR(line->colour));
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
@ -427,8 +454,9 @@ void line_info_print(ToxWindow *self)
|
||||
wprintw(win, "$ ");
|
||||
wattroff(win, COLOR_PAIR(GREEN));
|
||||
|
||||
if (line->msg[0])
|
||||
if (line->msg[0]) {
|
||||
wprintw(win, "%s", line->msg);
|
||||
}
|
||||
|
||||
wprintw(win, "\n");
|
||||
break;
|
||||
@ -492,8 +520,9 @@ void line_info_print(ToxWindow *self)
|
||||
}
|
||||
|
||||
/* keep calling until queue is empty */
|
||||
if (hst->queue_sz > 0)
|
||||
if (hst->queue_sz > 0) {
|
||||
line_info_print(self);
|
||||
}
|
||||
}
|
||||
|
||||
/* puts msg in specified line_info msg buffer */
|
||||
@ -518,16 +547,20 @@ void line_info_set(ToxWindow *self, uint32_t id, char *msg)
|
||||
|
||||
static void line_info_scroll_up(struct history *hst)
|
||||
{
|
||||
if (hst->line_start->prev)
|
||||
if (hst->line_start->prev) {
|
||||
hst->line_start = hst->line_start->prev;
|
||||
else sound_notify(NULL, notif_error, NT_ALWAYS, NULL);
|
||||
} else {
|
||||
sound_notify(NULL, notif_error, NT_ALWAYS, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
static void line_info_scroll_down(struct history *hst)
|
||||
{
|
||||
if (hst->line_start->next)
|
||||
if (hst->line_start->next) {
|
||||
hst->line_start = hst->line_start->next;
|
||||
else sound_notify(NULL, notif_error, NT_ALWAYS, NULL);
|
||||
} else {
|
||||
sound_notify(NULL, notif_error, NT_ALWAYS, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
static void line_info_page_up(ToxWindow *self, struct history *hst)
|
||||
@ -538,8 +571,9 @@ static void line_info_page_up(ToxWindow *self, struct history *hst)
|
||||
int jump_dist = y2 / 2;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < jump_dist && hst->line_start->prev; ++i)
|
||||
for (i = 0; i < jump_dist && hst->line_start->prev; ++i) {
|
||||
hst->line_start = hst->line_start->prev;
|
||||
}
|
||||
}
|
||||
|
||||
static void line_info_page_down(ToxWindow *self, struct history *hst)
|
||||
@ -550,8 +584,9 @@ static void line_info_page_down(ToxWindow *self, struct history *hst)
|
||||
int jump_dist = y2 / 2;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < jump_dist && hst->line_start->next; ++i)
|
||||
for (i = 0; i < jump_dist && hst->line_start->next; ++i) {
|
||||
hst->line_start = hst->line_start->next;
|
||||
}
|
||||
}
|
||||
|
||||
bool line_info_onKey(ToxWindow *self, wint_t key)
|
||||
|
64
src/log.c
64
src/log.c
@ -45,8 +45,9 @@ extern struct user_settings *user_settings;
|
||||
Returns 0 on success, -1 if the path is too long */
|
||||
static int get_log_path(char *dest, int destsize, char *name, const char *selfkey, const char *otherkey, int logtype)
|
||||
{
|
||||
if (!valid_nick(name))
|
||||
if (!valid_nick(name)) {
|
||||
name = UNKNOWN_NAME;
|
||||
}
|
||||
|
||||
const char *namedash = logtype == LOG_PROMPT ? "" : "-";
|
||||
const char *set_path = user_settings->chatlogs_path;
|
||||
@ -85,10 +86,11 @@ static int get_log_path(char *dest, int destsize, char *name, const char *selfke
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (!string_is_empty(set_path))
|
||||
if (!string_is_empty(set_path)) {
|
||||
snprintf(dest, destsize, "%s%s-%s%s%s.log", set_path, self_id, name, namedash, other_id);
|
||||
else
|
||||
} else {
|
||||
snprintf(dest, destsize, "%s%s%s-%s%s%s.log", user_config_dir, LOGDIR, self_id, name, namedash, other_id);
|
||||
}
|
||||
|
||||
free(user_config_dir);
|
||||
|
||||
@ -98,19 +100,22 @@ static int get_log_path(char *dest, int destsize, char *name, const char *selfke
|
||||
/* Opens log file or creates a new one */
|
||||
static int init_logging_session(char *name, const char *selfkey, const char *otherkey, struct chatlog *log, int logtype)
|
||||
{
|
||||
if (selfkey == NULL || (logtype == LOG_CHAT && otherkey == NULL))
|
||||
if (selfkey == NULL || (logtype == LOG_CHAT && otherkey == NULL)) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
char log_path[MAX_STR_SIZE];
|
||||
|
||||
if (get_log_path(log_path, sizeof(log_path), name, selfkey, otherkey, logtype) == -1)
|
||||
if (get_log_path(log_path, sizeof(log_path), name, selfkey, otherkey, logtype) == -1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
log->file = fopen(log_path, "a+");
|
||||
snprintf(log->path, sizeof(log->path), "%s", log_path);
|
||||
|
||||
if (log->file == NULL)
|
||||
if (log->file == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -119,8 +124,9 @@ static int init_logging_session(char *name, const char *selfkey, const char *oth
|
||||
|
||||
void write_to_log(const char *msg, const char *name, struct chatlog *log, bool event)
|
||||
{
|
||||
if (!log->log_on)
|
||||
if (!log->log_on) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (log->file == NULL) {
|
||||
log->log_on = false;
|
||||
@ -129,10 +135,11 @@ void write_to_log(const char *msg, const char *name, struct chatlog *log, bool e
|
||||
|
||||
char name_frmt[TOXIC_MAX_NAME_LENGTH + 3];
|
||||
|
||||
if (event)
|
||||
if (event) {
|
||||
snprintf(name_frmt, sizeof(name_frmt), "* %s", name);
|
||||
else
|
||||
} else {
|
||||
snprintf(name_frmt, sizeof(name_frmt), "%s:", name);
|
||||
}
|
||||
|
||||
const char *t = user_settings->log_timestamp_format;
|
||||
char s[MAX_STR_SIZE];
|
||||
@ -147,8 +154,9 @@ void write_to_log(const char *msg, const char *name, struct chatlog *log, bool e
|
||||
|
||||
void log_disable(struct chatlog *log)
|
||||
{
|
||||
if (log->file != NULL)
|
||||
if (log->file != NULL) {
|
||||
fclose(log->file);
|
||||
}
|
||||
|
||||
memset(log, 0, sizeof(struct chatlog));
|
||||
}
|
||||
@ -157,8 +165,9 @@ int log_enable(char *name, const char *selfkey, const char *otherkey, struct cha
|
||||
{
|
||||
log->log_on = true;
|
||||
|
||||
if (log->file != NULL)
|
||||
if (log->file != NULL) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (init_logging_session(name, selfkey, otherkey, log, logtype) == -1) {
|
||||
log_disable(log);
|
||||
@ -171,18 +180,21 @@ int log_enable(char *name, const char *selfkey, const char *otherkey, struct cha
|
||||
/* Loads previous history from chat log */
|
||||
void load_chat_history(ToxWindow *self, struct chatlog *log)
|
||||
{
|
||||
if (log->file == NULL)
|
||||
if (log->file == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
off_t sz = file_size(log->path);
|
||||
|
||||
if (sz <= 0)
|
||||
if (sz <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
char *hstbuf = malloc(sz + 1);
|
||||
|
||||
if (hstbuf == NULL)
|
||||
if (hstbuf == NULL) {
|
||||
exit_toxic_err("failed in load_chat_history", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
if (fseek(log->file, 0L, SEEK_SET) == -1) {
|
||||
free(hstbuf);
|
||||
@ -204,8 +216,9 @@ void load_chat_history(ToxWindow *self, struct chatlog *log)
|
||||
|
||||
/* start at end and backtrace L lines or to the beginning of buffer */
|
||||
for (start = sz - 1; start >= 0 && count < L; --start) {
|
||||
if (hstbuf[start] == '\n')
|
||||
if (hstbuf[start] == '\n') {
|
||||
++count;
|
||||
}
|
||||
}
|
||||
|
||||
const char *line = strtok(&hstbuf[start + 1], "\n");
|
||||
@ -238,33 +251,40 @@ int rename_logfile(char *src, char *dest, const char *selfkey, const char *other
|
||||
log_on = log->log_on;
|
||||
}
|
||||
|
||||
if (log_on)
|
||||
if (log_on) {
|
||||
log_disable(log);
|
||||
}
|
||||
|
||||
char newpath[MAX_STR_SIZE];
|
||||
char oldpath[MAX_STR_SIZE];
|
||||
|
||||
if (get_log_path(oldpath, sizeof(oldpath), src, selfkey, otherkey, LOG_CHAT) == -1)
|
||||
if (get_log_path(oldpath, sizeof(oldpath), src, selfkey, otherkey, LOG_CHAT) == -1) {
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if (!file_exists(oldpath))
|
||||
if (!file_exists(oldpath)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (get_log_path(newpath, sizeof(newpath), dest, selfkey, otherkey, LOG_CHAT) == -1)
|
||||
if (get_log_path(newpath, sizeof(newpath), dest, selfkey, otherkey, LOG_CHAT) == -1) {
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if (rename(oldpath, newpath) != 0)
|
||||
if (rename(oldpath, newpath) != 0) {
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if (log_on)
|
||||
if (log_on) {
|
||||
log_enable(dest, selfkey, otherkey, log, LOG_CHAT);
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
on_error:
|
||||
|
||||
if (log_on)
|
||||
if (log_on) {
|
||||
log_enable(src, selfkey, otherkey, log, LOG_CHAT);
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
@ -50,8 +50,9 @@ void cqueue_add(struct chat_queue *q, const char *msg, size_t len, uint8_t type,
|
||||
|
||||
struct cqueue_msg *new_m = malloc(sizeof(struct cqueue_msg));
|
||||
|
||||
if (new_m == NULL)
|
||||
if (new_m == NULL) {
|
||||
exit_toxic_err("failed in cqueue_message", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
snprintf(new_m->message, sizeof(new_m->message), "%s", msg);
|
||||
new_m->len = len;
|
||||
@ -118,8 +119,9 @@ void cqueue_remove(ToxWindow *self, Tox *m, uint32_t receipt)
|
||||
struct cqueue_msg *next = msg->next;
|
||||
|
||||
if (msg->prev == NULL) { /* root */
|
||||
if (next)
|
||||
if (next) {
|
||||
next->prev = NULL;
|
||||
}
|
||||
|
||||
free(msg);
|
||||
q->root = next;
|
||||
|
@ -93,19 +93,21 @@ void get_time_str(char *buf, int bufsize)
|
||||
/* Converts seconds to string in format HH:mm:ss; truncates hours and minutes when necessary */
|
||||
void get_elapsed_time_str(char *buf, int bufsize, time_t secs)
|
||||
{
|
||||
if (!secs)
|
||||
if (!secs) {
|
||||
return;
|
||||
}
|
||||
|
||||
long int seconds = secs % 60;
|
||||
long int minutes = (secs % 3600) / 60;
|
||||
long int hours = secs / 3600;
|
||||
|
||||
if (!minutes && !hours)
|
||||
if (!minutes && !hours) {
|
||||
snprintf(buf, bufsize, "%.2ld", seconds);
|
||||
else if (!hours)
|
||||
} else if (!hours) {
|
||||
snprintf(buf, bufsize, "%ld:%.2ld", minutes, seconds);
|
||||
else
|
||||
} else {
|
||||
snprintf(buf, bufsize, "%ld:%.2ld:%.2ld", hours, minutes, seconds);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
@ -117,8 +119,9 @@ void get_elapsed_time_str(char *buf, int bufsize, time_t secs)
|
||||
*/
|
||||
int hex_string_to_bin(const char *hex_string, size_t hex_len, char *output, size_t output_size)
|
||||
{
|
||||
if (output_size == 0 || hex_len != output_size * 2)
|
||||
if (output_size == 0 || hex_len != output_size * 2) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < output_size; ++i) {
|
||||
sscanf(hex_string, "%2hhx", &output[i]);
|
||||
@ -130,8 +133,9 @@ int hex_string_to_bin(const char *hex_string, size_t hex_len, char *output, size
|
||||
|
||||
int hex_string_to_bytes(char *buf, int size, const char *keystr)
|
||||
{
|
||||
if (size % 2 != 0)
|
||||
if (size % 2 != 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
int i, res;
|
||||
const char *pos = keystr;
|
||||
@ -140,8 +144,9 @@ int hex_string_to_bytes(char *buf, int size, const char *keystr)
|
||||
res = sscanf(pos, "%2hhx", &buf[i]);
|
||||
pos += 2;
|
||||
|
||||
if (res == EOF || res < 1)
|
||||
if (res == EOF || res < 1) {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
@ -154,13 +159,15 @@ int hex_string_to_bytes(char *buf, int size, const char *keystr)
|
||||
*/
|
||||
int bin_id_to_string(const char *bin_id, size_t bin_id_size, char *output, size_t output_size)
|
||||
{
|
||||
if (bin_id_size != TOX_ADDRESS_SIZE || output_size < (TOX_ADDRESS_SIZE * 2 + 1))
|
||||
if (bin_id_size != TOX_ADDRESS_SIZE || output_size < (TOX_ADDRESS_SIZE * 2 + 1)) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < TOX_ADDRESS_SIZE; ++i)
|
||||
for (i = 0; i < TOX_ADDRESS_SIZE; ++i) {
|
||||
snprintf(&output[i * 2], output_size - (i * 2), "%02X", bin_id[i] & 0xff);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -168,8 +175,9 @@ int bin_id_to_string(const char *bin_id, size_t bin_id_size, char *output, size_
|
||||
/* Returns 1 if the string is empty, 0 otherwise */
|
||||
int string_is_empty(const char *string)
|
||||
{
|
||||
if (!string)
|
||||
if (!string) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return string[0] == '\0';
|
||||
}
|
||||
@ -177,8 +185,9 @@ int string_is_empty(const char *string)
|
||||
/* Returns 1 if the string is empty, 0 otherwise */
|
||||
int wstring_is_empty(const wchar_t *string)
|
||||
{
|
||||
if (!string)
|
||||
if (!string) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return string[0] == L'\0';
|
||||
}
|
||||
@ -188,11 +197,13 @@ int mbs_to_wcs_buf(wchar_t *buf, const char *string, size_t n)
|
||||
{
|
||||
size_t len = mbstowcs(NULL, string, 0) + 1;
|
||||
|
||||
if (n < len)
|
||||
if (n < len) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if ((len = mbstowcs(buf, string, n)) == (size_t) - 1)
|
||||
if ((len = mbstowcs(buf, string, n)) == (size_t) - 1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return len;
|
||||
}
|
||||
@ -202,11 +213,13 @@ int wcs_to_mbs_buf(char *buf, const wchar_t *string, size_t n)
|
||||
{
|
||||
size_t len = wcstombs(NULL, string, 0) + 1;
|
||||
|
||||
if (n < len)
|
||||
if (n < len) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if ((len = wcstombs(buf, string, n)) == (size_t) - 1)
|
||||
if ((len = wcstombs(buf, string, n)) == (size_t) - 1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return len;
|
||||
}
|
||||
@ -225,8 +238,9 @@ int qsort_strcasecmp_hlpr(const void *str1, const void *str2)
|
||||
- must not contain a newline or tab seqeunce */
|
||||
int valid_nick(const char *nick)
|
||||
{
|
||||
if (!nick[0] || nick[0] == ' ')
|
||||
if (!nick[0] || nick[0] == ' ') {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int i;
|
||||
|
||||
@ -238,7 +252,9 @@ int valid_nick(const char *nick)
|
||||
|| nick[i] == '\v'
|
||||
|| nick[i] == '\r')
|
||||
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
return 1;
|
||||
@ -250,8 +266,9 @@ void filter_str(char *str, size_t len)
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < len; ++i) {
|
||||
if (str[i] == '\n' || str[i] == '\r' || str[i] == '\t' || str[i] == '\v' || str[i] == '\0')
|
||||
if (str[i] == '\n' || str[i] == '\r' || str[i] == '\t' || str[i] == '\v' || str[i] == '\0') {
|
||||
str[i] = ' ';
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -263,22 +280,26 @@ size_t get_file_name(char *namebuf, size_t bufsize, const char *pathname)
|
||||
int len = strlen(pathname) - 1;
|
||||
char *path = strdup(pathname);
|
||||
|
||||
if (path == NULL)
|
||||
if (path == NULL) {
|
||||
exit_toxic_err("failed in get_file_name", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
while (len >= 0 && pathname[len] == '/')
|
||||
while (len >= 0 && pathname[len] == '/') {
|
||||
path[len--] = '\0';
|
||||
}
|
||||
|
||||
char *finalname = strdup(path);
|
||||
|
||||
if (finalname == NULL)
|
||||
if (finalname == NULL) {
|
||||
exit_toxic_err("failed in get_file_name", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
const char *basenm = strrchr(path, '/');
|
||||
|
||||
if (basenm != NULL) {
|
||||
if (basenm[1])
|
||||
if (basenm[1]) {
|
||||
strcpy(finalname, &basenm[1]);
|
||||
}
|
||||
}
|
||||
|
||||
snprintf(namebuf, bufsize, "%s", finalname);
|
||||
@ -295,13 +316,15 @@ size_t get_file_name(char *namebuf, size_t bufsize, const char *pathname)
|
||||
*/
|
||||
size_t get_base_dir(const char *path, size_t path_len, char *dir)
|
||||
{
|
||||
if (path_len == 0 || path == NULL)
|
||||
if (path_len == 0 || path == NULL) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
size_t dir_len = char_rfind(path, '/', path_len);
|
||||
|
||||
if (dir_len != 0 && dir_len < path_len)
|
||||
++dir_len; /* Leave trailing slash */
|
||||
if (dir_len != 0 && dir_len < path_len) {
|
||||
++dir_len; /* Leave trailing slash */
|
||||
}
|
||||
|
||||
memcpy(dir, path, dir_len);
|
||||
dir[dir_len] = '\0';
|
||||
@ -314,8 +337,9 @@ void str_to_lower(char *str)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; str[i]; ++i)
|
||||
for (i = 0; str[i]; ++i) {
|
||||
str[i] = tolower(str[i]);
|
||||
}
|
||||
}
|
||||
|
||||
/* puts friendnum's nick in buf, truncating at TOXIC_MAX_NAME_LENGTH if necessary.
|
||||
@ -401,8 +425,9 @@ int char_find(int idx, const char *s, char ch)
|
||||
int i = idx;
|
||||
|
||||
for (i = idx; s[i]; ++i) {
|
||||
if (s[i] == ch)
|
||||
if (s[i] == ch) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return i;
|
||||
@ -419,8 +444,9 @@ int char_rfind(const char *s, char ch, int len)
|
||||
int i = 0;
|
||||
|
||||
for (i = len; i > 0; --i) {
|
||||
if (s[i] == ch)
|
||||
if (s[i] == ch) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return i;
|
||||
@ -460,8 +486,9 @@ off_t file_size(const char *path)
|
||||
{
|
||||
struct stat st;
|
||||
|
||||
if (stat(path, &st) == -1)
|
||||
if (stat(path, &st) == -1) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return st.st_size;
|
||||
}
|
||||
@ -474,13 +501,15 @@ int check_file_signature(const char *signature, size_t size, FILE *fp)
|
||||
{
|
||||
char buf[size];
|
||||
|
||||
if (fread(buf, size, 1, fp) != 1)
|
||||
if (fread(buf, size, 1, fp) != 1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
int ret = memcmp(signature, buf, size);
|
||||
|
||||
if (fseek(fp, 0L, SEEK_SET) == -1)
|
||||
if (fseek(fp, 0L, SEEK_SET) == -1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return ret == 0 ? 0 : 1;
|
||||
}
|
||||
@ -490,10 +519,11 @@ void set_window_title(ToxWindow *self, const char *title, int len)
|
||||
{
|
||||
char cpy[TOXIC_MAX_NAME_LENGTH + 1];
|
||||
|
||||
if (self->is_groupchat) /* keep groupnumber in title */
|
||||
if (self->is_groupchat) { /* keep groupnumber in title */
|
||||
snprintf(cpy, sizeof(cpy), "%d %s", self->num, title);
|
||||
else
|
||||
} else {
|
||||
snprintf(cpy, sizeof(cpy), "%s", title);
|
||||
}
|
||||
|
||||
if (len > MAX_WINDOW_NAME_LENGTH) {
|
||||
strcpy(&cpy[MAX_WINDOW_NAME_LENGTH - 3], "...");
|
||||
|
@ -97,42 +97,49 @@ static int load_nameserver_list(const char *path)
|
||||
{
|
||||
FILE *fp = fopen(path, "r");
|
||||
|
||||
if (fp == NULL)
|
||||
if (fp == NULL) {
|
||||
return -2;
|
||||
}
|
||||
|
||||
char line[MAX_SERVER_LINE];
|
||||
|
||||
while (fgets(line, sizeof(line), fp) && Nameservers.lines < MAX_SERVERS) {
|
||||
int linelen = strlen(line);
|
||||
|
||||
if (linelen < SERVER_KEY_SIZE * 2 + 5)
|
||||
if (linelen < SERVER_KEY_SIZE * 2 + 5) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (line[linelen - 1] == '\n')
|
||||
if (line[linelen - 1] == '\n') {
|
||||
line[--linelen] = '\0';
|
||||
}
|
||||
|
||||
const char *name = strtok(line, " ");
|
||||
const char *keystr = strtok(NULL, " ");
|
||||
|
||||
if (name == NULL || keystr == NULL)
|
||||
if (name == NULL || keystr == NULL) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (strlen(keystr) != SERVER_KEY_SIZE * 2)
|
||||
if (strlen(keystr) != SERVER_KEY_SIZE * 2) {
|
||||
continue;
|
||||
}
|
||||
|
||||
snprintf(Nameservers.names[Nameservers.lines], sizeof(Nameservers.names[Nameservers.lines]), "%s", name);
|
||||
int res = hex_string_to_bytes(Nameservers.keys[Nameservers.lines], SERVER_KEY_SIZE, keystr);
|
||||
|
||||
if (res == -1)
|
||||
if (res == -1) {
|
||||
continue;
|
||||
}
|
||||
|
||||
++Nameservers.lines;
|
||||
}
|
||||
|
||||
fclose(fp);
|
||||
|
||||
if (Nameservers.lines < 1)
|
||||
if (Nameservers.lines < 1) {
|
||||
return -3;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -145,8 +152,9 @@ static int load_nameserver_list(const char *path)
|
||||
*/
|
||||
static int parse_addr(const char *addr, char *namebuf, size_t namebuf_sz, char *dombuf, size_t dombuf_sz)
|
||||
{
|
||||
if (strlen(addr) >= (MAX_STR_SIZE - strlen(NAMESERVER_API_PATH)))
|
||||
if (strlen(addr) >= (MAX_STR_SIZE - strlen(NAMESERVER_API_PATH))) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
char tmpaddr[MAX_STR_SIZE];
|
||||
char *tmpname = NULL;
|
||||
@ -156,8 +164,9 @@ static int parse_addr(const char *addr, char *namebuf, size_t namebuf_sz, char *
|
||||
tmpname = strtok(tmpaddr, "@");
|
||||
tmpdom = strtok(NULL, "");
|
||||
|
||||
if (tmpname == NULL || tmpdom == NULL)
|
||||
if (tmpname == NULL || tmpdom == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
str_to_lower(tmpdom);
|
||||
snprintf(namebuf, namebuf_sz, "%s", tmpname);
|
||||
@ -197,23 +206,27 @@ static int process_response(struct Recv_Curl_Data *recv_data)
|
||||
{
|
||||
size_t prefix_size = strlen(ID_PREFIX);
|
||||
|
||||
if (recv_data->length < TOX_ADDRESS_SIZE * 2 + prefix_size)
|
||||
if (recv_data->length < TOX_ADDRESS_SIZE * 2 + prefix_size) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
const char *IDstart = strstr(recv_data->data, ID_PREFIX);
|
||||
|
||||
if (IDstart == NULL)
|
||||
if (IDstart == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (strlen(IDstart) < TOX_ADDRESS_SIZE * 2 + prefix_size)
|
||||
if (strlen(IDstart) < TOX_ADDRESS_SIZE * 2 + prefix_size) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
char ID_string[TOX_ADDRESS_SIZE * 2 + 1];
|
||||
memcpy(ID_string, IDstart + prefix_size, TOX_ADDRESS_SIZE * 2);
|
||||
ID_string[TOX_ADDRESS_SIZE * 2] = 0;
|
||||
|
||||
if (hex_string_to_bin(ID_string, strlen(ID_string), t_data.id_bin, sizeof(t_data.id_bin)) == -1)
|
||||
if (hex_string_to_bin(ID_string, strlen(ID_string), t_data.id_bin, sizeof(t_data.id_bin)) == -1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -234,10 +247,11 @@ void *lookup_thread_func(void *data)
|
||||
char real_domain[MAX_DOMAIN_SIZE];
|
||||
|
||||
if (!get_domain_match(nameserver_key, real_domain, sizeof(real_domain), input_domain)) {
|
||||
if (!strcasecmp(input_domain, "utox.org"))
|
||||
if (!strcasecmp(input_domain, "utox.org")) {
|
||||
lookup_error(self, "utox.org uses deprecated DNS-based lookups and is no longer supported by Toxic.");
|
||||
else
|
||||
} else {
|
||||
lookup_error(self, "Name server domain not found.");
|
||||
}
|
||||
|
||||
kill_lookup_thread();
|
||||
}
|
||||
|
168
src/notify.c
168
src/notify.c
@ -104,21 +104,24 @@ struct _ActiveNotifications {
|
||||
/* coloured tab notifications: primary notification type */
|
||||
static void tab_notify(ToxWindow *self, uint64_t flags)
|
||||
{
|
||||
if (self == NULL)
|
||||
if (self == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (flags & NT_WNDALERT_0)
|
||||
if (flags & NT_WNDALERT_0) {
|
||||
self->alert = WINDOW_ALERT_0;
|
||||
else if ( (flags & NT_WNDALERT_1) && (!self->alert || self->alert > WINDOW_ALERT_0) )
|
||||
} else if ((flags & NT_WNDALERT_1) && (!self->alert || self->alert > WINDOW_ALERT_0)) {
|
||||
self->alert = WINDOW_ALERT_1;
|
||||
else if ( (flags & NT_WNDALERT_2) && (!self->alert || self->alert > WINDOW_ALERT_1) )
|
||||
} else if ((flags & NT_WNDALERT_2) && (!self->alert || self->alert > WINDOW_ALERT_1)) {
|
||||
self->alert = WINDOW_ALERT_2;
|
||||
}
|
||||
}
|
||||
|
||||
static bool notifications_are_disabled(uint64_t flags)
|
||||
{
|
||||
if (user_settings->alerts != ALERTS_ENABLED)
|
||||
if (user_settings->alerts != ALERTS_ENABLED) {
|
||||
return true;
|
||||
}
|
||||
|
||||
bool res = (flags & NT_RESTOL) && (Control.cooldown > get_unix_time());
|
||||
#ifdef X11
|
||||
@ -161,7 +164,9 @@ void m_open_device()
|
||||
{
|
||||
last_opened_update = get_unix_time();
|
||||
|
||||
if (device_opened) return;
|
||||
if (device_opened) {
|
||||
return;
|
||||
}
|
||||
|
||||
/* Blah error check */
|
||||
open_primary_device(output, &Control.device_idx, 48000, 20, 1);
|
||||
@ -171,7 +176,9 @@ void m_open_device()
|
||||
|
||||
void m_close_device()
|
||||
{
|
||||
if (!device_opened) return;
|
||||
if (!device_opened) {
|
||||
return;
|
||||
}
|
||||
|
||||
close_device(output, Control.device_idx);
|
||||
|
||||
@ -198,15 +205,18 @@ void graceful_clear()
|
||||
|
||||
#endif
|
||||
|
||||
if (actives[i].id_indicator)
|
||||
if (actives[i].id_indicator) {
|
||||
*actives[i].id_indicator = -1; /* reset indicator value */
|
||||
}
|
||||
|
||||
if ( actives[i].looping ) {
|
||||
if (actives[i].looping) {
|
||||
stop_sound(i);
|
||||
} else {
|
||||
if (!is_playing(actives[i].source))
|
||||
if (!is_playing(actives[i].source)) {
|
||||
memset(&actives[i], 0, sizeof(struct _ActiveNotifications));
|
||||
else break;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -241,7 +251,9 @@ void *do_playing(void *_p)
|
||||
|
||||
for (i = 0; i < ACTIVE_NOTIFS_MAX; i ++) {
|
||||
|
||||
if (actives[i].looping) has_looping = true;
|
||||
if (actives[i].looping) {
|
||||
has_looping = true;
|
||||
}
|
||||
|
||||
test_active_notify = actives[i].active && !actives[i].looping;
|
||||
#ifdef BOX_NOTIFY
|
||||
@ -249,8 +261,9 @@ void *do_playing(void *_p)
|
||||
#endif
|
||||
|
||||
if (test_active_notify) {
|
||||
if (actives[i].id_indicator)
|
||||
if (actives[i].id_indicator) {
|
||||
*actives[i].id_indicator = -1; /* reset indicator value */
|
||||
}
|
||||
|
||||
if (!is_playing(actives[i].source)) {
|
||||
/* Close */
|
||||
@ -267,8 +280,9 @@ void *do_playing(void *_p)
|
||||
notify_notification_close(actives[i].box, &ignore);
|
||||
actives[i].box = NULL;
|
||||
|
||||
if (actives[i].id_indicator)
|
||||
if (actives[i].id_indicator) {
|
||||
*actives[i].id_indicator = -1; /* reset indicator value */
|
||||
}
|
||||
|
||||
if (!actives[i].looping && !is_playing(actives[i].source)) {
|
||||
/* stop source if not looping or playing, just terminate box */
|
||||
@ -303,7 +317,7 @@ int play_source(uint32_t source, uint32_t buffer, bool looping)
|
||||
|
||||
for (; i < ACTIVE_NOTIFS_MAX && actives[i].active; i ++);
|
||||
|
||||
if ( i == ACTIVE_NOTIFS_MAX ) {
|
||||
if (i == ACTIVE_NOTIFS_MAX) {
|
||||
return -1; /* Full */
|
||||
}
|
||||
|
||||
@ -338,8 +352,9 @@ void *do_playing(void *_p)
|
||||
notify_notification_close(actives[i].box, &ignore);
|
||||
actives[i].box = NULL;
|
||||
|
||||
if (actives[i].id_indicator)
|
||||
if (actives[i].id_indicator) {
|
||||
*actives[i].id_indicator = -1; /* reset indicator value */
|
||||
}
|
||||
|
||||
memset(&actives[i], 0, sizeof(struct _ActiveNotifications));
|
||||
}
|
||||
@ -364,8 +379,9 @@ void graceful_clear()
|
||||
actives[i].box = NULL;
|
||||
}
|
||||
|
||||
if (actives[i].id_indicator)
|
||||
if (actives[i].id_indicator) {
|
||||
*actives[i].id_indicator = -1; /* reset indicator value */
|
||||
}
|
||||
|
||||
memset(&actives[i], 0, sizeof(struct _ActiveNotifications));
|
||||
}
|
||||
@ -391,13 +407,14 @@ int init_notify(int login_cooldown, int notification_timeout)
|
||||
|
||||
#if defined(SOUND_NOTIFY) || defined(BOX_NOTIFY)
|
||||
|
||||
if (pthread_mutex_init(Control.poll_mutex, NULL) != 0)
|
||||
if (pthread_mutex_init(Control.poll_mutex, NULL) != 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
Control.poll_active = 1;
|
||||
pthread_t thread;
|
||||
|
||||
if (pthread_create(&thread, NULL, do_playing, NULL) != 0 || pthread_detach(thread) != 0 ) {
|
||||
if (pthread_create(&thread, NULL, do_playing, NULL) != 0 || pthread_detach(thread) != 0) {
|
||||
pthread_mutex_destroy(Control.poll_mutex);
|
||||
Control.poll_active = 0;
|
||||
return -1;
|
||||
@ -419,7 +436,7 @@ void terminate_notify()
|
||||
#if defined(SOUND_NOTIFY) || defined(BOX_NOTIFY)
|
||||
control_lock();
|
||||
|
||||
if ( !Control.poll_active ) {
|
||||
if (!Control.poll_active) {
|
||||
control_unlock();
|
||||
return;
|
||||
}
|
||||
@ -433,7 +450,9 @@ void terminate_notify()
|
||||
#ifdef SOUND_NOTIFY
|
||||
int i = 0;
|
||||
|
||||
for (; i < SOUNDS_SIZE; i ++) free(Control.sounds[i]);
|
||||
for (; i < SOUNDS_SIZE; i ++) {
|
||||
free(Control.sounds[i]);
|
||||
}
|
||||
|
||||
alutExit();
|
||||
#endif /* SOUND_NOTIFY */
|
||||
@ -446,7 +465,9 @@ void terminate_notify()
|
||||
#ifdef SOUND_NOTIFY
|
||||
int set_sound(Notification sound, const char *value)
|
||||
{
|
||||
if (sound == silent) return 0;
|
||||
if (sound == silent) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
free(Control.sounds[sound]);
|
||||
|
||||
@ -487,11 +508,14 @@ int play_notify_sound(Notification notif, uint64_t flags)
|
||||
{
|
||||
int rc = -1;
|
||||
|
||||
if (flags & NT_BEEP) beep();
|
||||
if (flags & NT_BEEP) {
|
||||
beep();
|
||||
}
|
||||
|
||||
if (notif != silent) {
|
||||
if ( !Control.poll_active || !Control.sounds[notif] )
|
||||
if (!Control.poll_active || !Control.sounds[notif]) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
rc = play_sound_internal(notif, flags & NT_LOOP ? 1 : 0);
|
||||
}
|
||||
@ -502,7 +526,7 @@ int play_notify_sound(Notification notif, uint64_t flags)
|
||||
|
||||
void stop_sound(int id)
|
||||
{
|
||||
if (id >= 0 && id < ACTIVE_NOTIFS_MAX && actives[id].looping && actives[id].active ) {
|
||||
if (id >= 0 && id < ACTIVE_NOTIFS_MAX && actives[id].looping && actives[id].active) {
|
||||
#ifdef BOX_NOTIFY
|
||||
|
||||
if (actives[id].box) {
|
||||
@ -512,8 +536,9 @@ void stop_sound(int id)
|
||||
|
||||
#endif
|
||||
|
||||
if (actives[id].id_indicator)
|
||||
if (actives[id].id_indicator) {
|
||||
*actives[id].id_indicator = -1;
|
||||
}
|
||||
|
||||
// alSourcei(actives[id].source, AL_LOOPING, false);
|
||||
alSourceStop(actives[id].source);
|
||||
@ -530,8 +555,9 @@ static int m_play_sound(Notification notif, uint64_t flags)
|
||||
return play_notify_sound(notif, flags);
|
||||
#else
|
||||
|
||||
if (notif != silent)
|
||||
if (notif != silent) {
|
||||
beep();
|
||||
}
|
||||
|
||||
return -1;
|
||||
#endif /* SOUND_NOTIFY */
|
||||
@ -547,23 +573,25 @@ int sound_notify(ToxWindow *self, Notification notif, uint64_t flags, int *id_in
|
||||
{
|
||||
tab_notify(self, flags);
|
||||
|
||||
if (notifications_are_disabled(flags))
|
||||
if (notifications_are_disabled(flags)) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
int id = -1;
|
||||
control_lock();
|
||||
|
||||
if (self && (!self->stb || self->stb->status != TOX_USER_STATUS_BUSY))
|
||||
if (self && (!self->stb || self->stb->status != TOX_USER_STATUS_BUSY)) {
|
||||
id = m_play_sound(notif, flags);
|
||||
else if (flags & NT_ALWAYS)
|
||||
} else if (flags & NT_ALWAYS) {
|
||||
id = m_play_sound(notif, flags);
|
||||
}
|
||||
|
||||
#if defined(BOX_NOTIFY) && !defined(SOUND_NOTIFY)
|
||||
|
||||
if (id == -1) {
|
||||
for (id = 0; id < ACTIVE_NOTIFS_MAX && actives[id].box; id++);
|
||||
|
||||
if ( id == ACTIVE_NOTIFS_MAX ) {
|
||||
if (id == ACTIVE_NOTIFS_MAX) {
|
||||
control_unlock();
|
||||
return -1; /* Full */
|
||||
}
|
||||
@ -571,7 +599,7 @@ int sound_notify(ToxWindow *self, Notification notif, uint64_t flags, int *id_in
|
||||
|
||||
#endif
|
||||
|
||||
if ( id_indicator && id != -1 ) {
|
||||
if (id_indicator && id != -1) {
|
||||
actives[id].id_indicator = id_indicator;
|
||||
*id_indicator = id;
|
||||
}
|
||||
@ -585,10 +613,13 @@ int sound_notify2(ToxWindow *self, Notification notif, uint64_t flags, int id)
|
||||
{
|
||||
tab_notify(self, flags);
|
||||
|
||||
if (notifications_are_disabled(flags))
|
||||
if (notifications_are_disabled(flags)) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (id < 0 || id >= ACTIVE_NOTIFS_MAX) return -1;
|
||||
if (id < 0 || id >= ACTIVE_NOTIFS_MAX) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
#ifdef SOUND_NOTIFY
|
||||
control_lock();
|
||||
@ -617,8 +648,9 @@ int sound_notify2(ToxWindow *self, Notification notif, uint64_t flags, int id)
|
||||
return id;
|
||||
#else
|
||||
|
||||
if (notif != silent)
|
||||
if (notif != silent) {
|
||||
beep();
|
||||
}
|
||||
|
||||
return 0;
|
||||
#endif /* SOUND_NOTIFY */
|
||||
@ -644,7 +676,7 @@ int box_notify(ToxWindow *self, Notification notif, uint64_t flags, int *id_indi
|
||||
|
||||
for (id = 0; id < ACTIVE_NOTIFS_MAX && actives[id].active; id ++);
|
||||
|
||||
if ( id == ACTIVE_NOTIFS_MAX ) {
|
||||
if (id == ACTIVE_NOTIFS_MAX) {
|
||||
control_unlock();
|
||||
return -1; /* Full */
|
||||
}
|
||||
@ -652,27 +684,33 @@ int box_notify(ToxWindow *self, Notification notif, uint64_t flags, int *id_indi
|
||||
actives[id].active = 1;
|
||||
actives[id].id_indicator = id_indicator;
|
||||
|
||||
if (id_indicator) *id_indicator = id;
|
||||
if (id_indicator) {
|
||||
*id_indicator = id;
|
||||
}
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
if (id == -1)
|
||||
if (id == -1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
#endif /* SOUND_NOTIFY */
|
||||
|
||||
snprintf(actives[id].title, sizeof(actives[id].title), "%s", title);
|
||||
|
||||
if (strlen(title) > 23) strcpy(actives[id].title + 20, "...");
|
||||
if (strlen(title) > 23) {
|
||||
strcpy(actives[id].title + 20, "...");
|
||||
}
|
||||
|
||||
va_list __ARGS__;
|
||||
va_start (__ARGS__, format);
|
||||
vsnprintf (actives[id].messages[0], MAX_BOX_MSG_LEN, format, __ARGS__);
|
||||
va_end (__ARGS__);
|
||||
va_start(__ARGS__, format);
|
||||
vsnprintf(actives[id].messages[0], MAX_BOX_MSG_LEN, format, __ARGS__);
|
||||
va_end(__ARGS__);
|
||||
|
||||
if (strlen(actives[id].messages[0]) > MAX_BOX_MSG_LEN - 3)
|
||||
if (strlen(actives[id].messages[0]) > MAX_BOX_MSG_LEN - 3) {
|
||||
strcpy(actives[id].messages[0] + MAX_BOX_MSG_LEN - 3, "...");
|
||||
}
|
||||
|
||||
actives[id].box = notify_notification_new(actives[id].title, actives[id].messages[0], NULL);
|
||||
actives[id].size++;
|
||||
@ -699,8 +737,9 @@ int box_notify2(ToxWindow *self, Notification notif, uint64_t flags, int id, con
|
||||
|
||||
#ifdef BOX_NOTIFY
|
||||
|
||||
if (sound_notify2(self, notif, flags, id) == -1)
|
||||
if (sound_notify2(self, notif, flags, id) == -1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
control_lock();
|
||||
|
||||
@ -710,12 +749,13 @@ int box_notify2(ToxWindow *self, Notification notif, uint64_t flags, int id, con
|
||||
}
|
||||
|
||||
va_list __ARGS__;
|
||||
va_start (__ARGS__, format);
|
||||
vsnprintf (actives[id].messages[actives[id].size], MAX_BOX_MSG_LEN, format, __ARGS__);
|
||||
va_end (__ARGS__);
|
||||
va_start(__ARGS__, format);
|
||||
vsnprintf(actives[id].messages[actives[id].size], MAX_BOX_MSG_LEN, format, __ARGS__);
|
||||
va_end(__ARGS__);
|
||||
|
||||
if (strlen(actives[id].messages[actives[id].size]) > MAX_BOX_MSG_LEN - 3)
|
||||
if (strlen(actives[id].messages[actives[id].size]) > MAX_BOX_MSG_LEN - 3) {
|
||||
strcpy(actives[id].messages[actives[id].size] + MAX_BOX_MSG_LEN - 3, "...");
|
||||
}
|
||||
|
||||
actives[id].size++;
|
||||
actives[id].n_timeout = get_unix_time() + Control.notif_timeout / 1000;
|
||||
@ -746,8 +786,9 @@ int box_silent_notify(ToxWindow *self, uint64_t flags, int *id_indicator, const
|
||||
{
|
||||
tab_notify(self, flags);
|
||||
|
||||
if (notifications_are_disabled(flags))
|
||||
if (notifications_are_disabled(flags)) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
#ifdef BOX_NOTIFY
|
||||
|
||||
@ -757,7 +798,7 @@ int box_silent_notify(ToxWindow *self, uint64_t flags, int *id_indicator, const
|
||||
|
||||
for (id = 0; id < ACTIVE_NOTIFS_MAX && actives[id].active; id ++);
|
||||
|
||||
if ( id == ACTIVE_NOTIFS_MAX ) {
|
||||
if (id == ACTIVE_NOTIFS_MAX) {
|
||||
control_unlock();
|
||||
return -1; /* Full */
|
||||
}
|
||||
@ -769,15 +810,18 @@ int box_silent_notify(ToxWindow *self, uint64_t flags, int *id_indicator, const
|
||||
|
||||
snprintf(actives[id].title, sizeof(actives[id].title), "%s", title);
|
||||
|
||||
if (strlen(title) > 23) strcpy(actives[id].title + 20, "...");
|
||||
if (strlen(title) > 23) {
|
||||
strcpy(actives[id].title + 20, "...");
|
||||
}
|
||||
|
||||
va_list __ARGS__;
|
||||
va_start (__ARGS__, format);
|
||||
vsnprintf (actives[id].messages[0], MAX_BOX_MSG_LEN, format, __ARGS__);
|
||||
va_end (__ARGS__);
|
||||
va_start(__ARGS__, format);
|
||||
vsnprintf(actives[id].messages[0], MAX_BOX_MSG_LEN, format, __ARGS__);
|
||||
va_end(__ARGS__);
|
||||
|
||||
if (strlen(actives[id].messages[0]) > MAX_BOX_MSG_LEN - 3)
|
||||
if (strlen(actives[id].messages[0]) > MAX_BOX_MSG_LEN - 3) {
|
||||
strcpy(actives[id].messages[0] + MAX_BOX_MSG_LEN - 3, "...");
|
||||
}
|
||||
|
||||
actives[id].active = 1;
|
||||
actives[id].box = notify_notification_new(actives[id].title, actives[id].messages[0], NULL);
|
||||
@ -800,25 +844,27 @@ int box_silent_notify2(ToxWindow *self, uint64_t flags, int id, const char *form
|
||||
{
|
||||
tab_notify(self, flags);
|
||||
|
||||
if (notifications_are_disabled(flags))
|
||||
if (notifications_are_disabled(flags)) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
#ifdef BOX_NOTIFY
|
||||
control_lock();
|
||||
|
||||
if (id < 0 || id >= ACTIVE_NOTIFS_MAX || !actives[id].box || actives[id].size >= MAX_BOX_MSG_LEN + 1 ) {
|
||||
if (id < 0 || id >= ACTIVE_NOTIFS_MAX || !actives[id].box || actives[id].size >= MAX_BOX_MSG_LEN + 1) {
|
||||
control_unlock();
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
va_list __ARGS__;
|
||||
va_start (__ARGS__, format);
|
||||
vsnprintf (actives[id].messages[actives[id].size], MAX_BOX_MSG_LEN, format, __ARGS__);
|
||||
va_end (__ARGS__);
|
||||
va_start(__ARGS__, format);
|
||||
vsnprintf(actives[id].messages[actives[id].size], MAX_BOX_MSG_LEN, format, __ARGS__);
|
||||
va_end(__ARGS__);
|
||||
|
||||
if (strlen(actives[id].messages[actives[id].size]) > MAX_BOX_MSG_LEN - 3)
|
||||
if (strlen(actives[id].messages[actives[id].size]) > MAX_BOX_MSG_LEN - 3) {
|
||||
strcpy(actives[id].messages[actives[id].size] + MAX_BOX_MSG_LEN - 3, "...");
|
||||
}
|
||||
|
||||
actives[id].size ++;
|
||||
actives[id].n_timeout = get_unix_time() + Control.notif_timeout / 1000;
|
||||
|
73
src/prompt.c
73
src/prompt.c
@ -162,8 +162,9 @@ void prompt_update_statusmessage(ToxWindow *prompt, Tox *m, const char *statusms
|
||||
TOX_ERR_SET_INFO err;
|
||||
tox_self_set_status_message(m, (uint8_t *) statusmsg, len, &err);
|
||||
|
||||
if (err != TOX_ERR_SET_INFO_OK)
|
||||
if (err != TOX_ERR_SET_INFO_OK) {
|
||||
line_info_add(prompt, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to set note (error %d)\n", err);
|
||||
}
|
||||
}
|
||||
|
||||
/* Updates own status in prompt statusbar */
|
||||
@ -184,8 +185,9 @@ TOX_CONNECTION prompt_selfConnectionStatus(void)
|
||||
Returns request number on success, -1 if queue is full. */
|
||||
static int add_friend_request(const char *public_key, const char *data)
|
||||
{
|
||||
if (FrndRequests.max_idx >= MAX_FRIEND_REQUESTS)
|
||||
if (FrndRequests.max_idx >= MAX_FRIEND_REQUESTS) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
int i;
|
||||
|
||||
@ -195,8 +197,9 @@ static int add_friend_request(const char *public_key, const char *data)
|
||||
memcpy(FrndRequests.request[i].key, public_key, TOX_PUBLIC_KEY_SIZE);
|
||||
snprintf(FrndRequests.request[i].msg, sizeof(FrndRequests.request[i].msg), "%s", data);
|
||||
|
||||
if (i == FrndRequests.max_idx)
|
||||
if (i == FrndRequests.max_idx) {
|
||||
++FrndRequests.max_idx;
|
||||
}
|
||||
|
||||
++FrndRequests.num_requests;
|
||||
|
||||
@ -215,11 +218,13 @@ static void prompt_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
|
||||
getyx(self->window, y, x);
|
||||
getmaxyx(self->window, y2, x2);
|
||||
|
||||
if (x2 <= 0 || y2 <= 0)
|
||||
if (x2 <= 0 || y2 <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (ctx->pastemode && key == '\r')
|
||||
if (ctx->pastemode && key == '\r') {
|
||||
key = '\n';
|
||||
}
|
||||
|
||||
/* ignore non-menu related input if active */
|
||||
if (self->help->active) {
|
||||
@ -232,8 +237,9 @@ static void prompt_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
|
||||
return;
|
||||
}
|
||||
|
||||
if (line_info_onKey(self, key))
|
||||
if (line_info_onKey(self, key)) {
|
||||
return;
|
||||
}
|
||||
|
||||
input_handle(self, key, x, y, x2, y2);
|
||||
|
||||
@ -241,12 +247,14 @@ static void prompt_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
|
||||
if (ctx->len > 1 && ctx->line[0] == '/') {
|
||||
int diff = -1;
|
||||
|
||||
if (wcsncmp(ctx->line, L"/avatar \"", wcslen(L"/avatar \"")) == 0)
|
||||
if (wcsncmp(ctx->line, L"/avatar \"", wcslen(L"/avatar \"")) == 0) {
|
||||
diff = dir_match(self, m, ctx->line, L"/avatar");
|
||||
}
|
||||
|
||||
#ifdef PYTHON
|
||||
else if (wcsncmp(ctx->line, L"/run \"", wcslen(L"/run \"")) == 0)
|
||||
else if (wcsncmp(ctx->line, L"/run \"", wcslen(L"/run \"")) == 0) {
|
||||
diff = dir_match(self, m, ctx->line, L"/run");
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@ -257,8 +265,9 @@ static void prompt_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
|
||||
{"busy"},
|
||||
};
|
||||
diff = complete_line(self, status_cmd_list, 3, 8);
|
||||
} else
|
||||
} else {
|
||||
diff = complete_line(self, glob_cmd_list, AC_NUM_GLOB_COMMANDS, MAX_CMDNAME_SIZE);
|
||||
}
|
||||
|
||||
if (diff != -1) {
|
||||
if (x + diff > x2 - 1) {
|
||||
@ -280,8 +289,9 @@ static void prompt_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
|
||||
|
||||
char line[MAX_STR_SIZE] = {0};
|
||||
|
||||
if (wcs_to_mbs_buf(line, ctx->line, MAX_STR_SIZE) == -1)
|
||||
if (wcs_to_mbs_buf(line, ctx->line, MAX_STR_SIZE) == -1) {
|
||||
memset(&line, 0, sizeof(line));
|
||||
}
|
||||
|
||||
line_info_add(self, NULL, NULL, NULL, PROMPT, 0, 0, "%s", line);
|
||||
execute(ctx->history, self, m, line, GLOBAL_COMMAND_MODE);
|
||||
@ -298,8 +308,9 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
|
||||
int x2, y2;
|
||||
getmaxyx(self->window, y2, x2);
|
||||
|
||||
if (y2 <= 0 || x2 <= 0)
|
||||
if (y2 <= 0 || x2 <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
ChatContext *ctx = self->chatwin;
|
||||
|
||||
@ -311,8 +322,9 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
|
||||
|
||||
curs_set(1);
|
||||
|
||||
if (ctx->len > 0)
|
||||
if (ctx->len > 0) {
|
||||
mvwprintw(ctx->linewin, 1, 0, "%ls", &ctx->line[ctx->start]);
|
||||
}
|
||||
|
||||
StatusBar *statusbar = self->stb;
|
||||
|
||||
@ -372,7 +384,7 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
|
||||
|
||||
pthread_mutex_lock(&Winthread.lock);
|
||||
size_t slen = tox_self_get_status_message_size(m);
|
||||
tox_self_get_status_message (m, (uint8_t *) statusmsg);
|
||||
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);
|
||||
@ -392,8 +404,9 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
|
||||
statusbar->statusmsg_len = maxlen;
|
||||
}
|
||||
|
||||
if (statusbar->statusmsg[0])
|
||||
if (statusbar->statusmsg[0]) {
|
||||
wprintw(statusbar->topline, " : %s", statusbar->statusmsg);
|
||||
}
|
||||
|
||||
pthread_mutex_unlock(&Winthread.lock);
|
||||
|
||||
@ -408,8 +421,9 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
|
||||
|
||||
wnoutrefresh(self->window);
|
||||
|
||||
if (self->help->active)
|
||||
if (self->help->active) {
|
||||
help_onDraw(self);
|
||||
}
|
||||
}
|
||||
|
||||
static void prompt_onConnectionChange(ToxWindow *self, Tox *m, uint32_t friendnum, TOX_CONNECTION connection_status)
|
||||
@ -419,8 +433,9 @@ static void prompt_onConnectionChange(ToxWindow *self, Tox *m, uint32_t friendnu
|
||||
char nick[TOX_MAX_NAME_LENGTH] = {0}; /* stop removing this initiation */
|
||||
get_nick_truncate(m, nick, friendnum);
|
||||
|
||||
if (!nick[0])
|
||||
if (!nick[0]) {
|
||||
snprintf(nick, sizeof(nick), "%s", UNKNOWN_NAME);
|
||||
}
|
||||
|
||||
char timefrmt[TIME_STR_SIZE];
|
||||
get_time_str(timefrmt, sizeof(timefrmt));
|
||||
@ -437,10 +452,10 @@ static void prompt_onConnectionChange(ToxWindow *self, Tox *m, uint32_t friendnu
|
||||
|
||||
if (self->active_box != -1)
|
||||
box_notify2(self, user_log_in, NT_WNDALERT_2 | NT_NOTIFWND | NT_RESTOL, self->active_box,
|
||||
"%s has come online", nick );
|
||||
"%s has come online", nick);
|
||||
else
|
||||
box_notify(self, user_log_in, NT_WNDALERT_2 | NT_NOTIFWND | NT_RESTOL, &self->active_box,
|
||||
"Toxic", "%s has come online", nick );
|
||||
"Toxic", "%s has come online", nick);
|
||||
} else if (connection_status == TOX_CONNECTION_NONE) {
|
||||
msg = "has gone offline";
|
||||
line_info_add(self, timefrmt, nick, NULL, DISCONNECTION, 0, RED, msg);
|
||||
@ -448,10 +463,10 @@ static void prompt_onConnectionChange(ToxWindow *self, Tox *m, uint32_t friendnu
|
||||
|
||||
if (self->active_box != -1)
|
||||
box_notify2(self, user_log_out, NT_WNDALERT_2 | NT_NOTIFWND | NT_RESTOL, self->active_box,
|
||||
"%s has gone offline", nick );
|
||||
"%s has gone offline", nick);
|
||||
else
|
||||
box_notify(self, user_log_out, NT_WNDALERT_2 | NT_NOTIFWND | NT_RESTOL, &self->active_box,
|
||||
"Toxic", "%s has gone offline", nick );
|
||||
"Toxic", "%s has gone offline", nick);
|
||||
}
|
||||
}
|
||||
|
||||
@ -482,8 +497,9 @@ void prompt_init_statusbar(ToxWindow *self, Tox *m)
|
||||
int x2, y2;
|
||||
getmaxyx(self->window, y2, x2);
|
||||
|
||||
if (y2 <= 0 || x2 <= 0)
|
||||
if (y2 <= 0 || x2 <= 0) {
|
||||
exit_toxic_err("failed in prompt_init_statusbar", FATALERR_CURSES);
|
||||
}
|
||||
|
||||
(void) y2;
|
||||
|
||||
@ -542,8 +558,9 @@ static void prompt_onInit(ToxWindow *self, Tox *m)
|
||||
int y2, x2;
|
||||
getmaxyx(self->window, y2, x2);
|
||||
|
||||
if (y2 <= 0 || x2 <= 0)
|
||||
if (y2 <= 0 || x2 <= 0) {
|
||||
exit_toxic_err("failed in prompt_onInit", FATALERR_CURSES);
|
||||
}
|
||||
|
||||
ChatContext *ctx = self->chatwin;
|
||||
ctx->history = subwin(self->window, y2 - CHATBOX_HEIGHT + 1, x2, 0, 0);
|
||||
@ -552,8 +569,9 @@ static void prompt_onInit(ToxWindow *self, Tox *m)
|
||||
ctx->log = calloc(1, sizeof(struct chatlog));
|
||||
ctx->hst = calloc(1, sizeof(struct history));
|
||||
|
||||
if (ctx->log == NULL || ctx->hst == NULL)
|
||||
if (ctx->log == NULL || ctx->hst == NULL) {
|
||||
exit_toxic_err("failed in prompt_onInit", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
line_info_init(ctx->hst);
|
||||
|
||||
@ -561,15 +579,17 @@ static void prompt_onInit(ToxWindow *self, Tox *m)
|
||||
char myid[TOX_ADDRESS_SIZE];
|
||||
tox_self_get_address(m, (uint8_t *) myid);
|
||||
|
||||
if (log_enable(self->name, myid, NULL, ctx->log, LOG_PROMPT) == -1)
|
||||
if (log_enable(self->name, myid, NULL, ctx->log, LOG_PROMPT) == -1) {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Warning: Log failed to initialize.");
|
||||
}
|
||||
}
|
||||
|
||||
scrollok(ctx->history, 0);
|
||||
wmove(self->window, y2 - CURS_Y_OFFSET, 0);
|
||||
|
||||
if (user_settings->show_welcome_msg == SHOW_WELCOME_MSG_ON)
|
||||
if (user_settings->show_welcome_msg == SHOW_WELCOME_MSG_ON) {
|
||||
print_welcome_msg(self);
|
||||
}
|
||||
}
|
||||
|
||||
ToxWindow new_prompt(void)
|
||||
@ -593,8 +613,9 @@ ToxWindow new_prompt(void)
|
||||
StatusBar *stb = calloc(1, sizeof(StatusBar));
|
||||
Help *help = calloc(1, sizeof(Help));
|
||||
|
||||
if (stb == NULL || chatwin == NULL || help == NULL)
|
||||
if (stb == NULL || chatwin == NULL || help == NULL) {
|
||||
exit_toxic_err("failed in new_prompt", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
ret.chatwin = chatwin;
|
||||
ret.stb = stb;
|
||||
|
@ -39,8 +39,9 @@ static PyObject *python_api_display(PyObject *self, PyObject *args)
|
||||
{
|
||||
const char *msg;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "s", &msg))
|
||||
if (!PyArg_ParseTuple(args, "s", &msg)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
api_display(msg);
|
||||
return Py_None;
|
||||
@ -51,13 +52,15 @@ static PyObject *python_api_get_nick(PyObject *self, PyObject *args)
|
||||
char *name;
|
||||
PyObject *ret;
|
||||
|
||||
if (!PyArg_ParseTuple(args, ""))
|
||||
if (!PyArg_ParseTuple(args, "")) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
name = api_get_nick();
|
||||
|
||||
if (name == NULL)
|
||||
if (name == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ret = Py_BuildValue("s", name);
|
||||
free(name);
|
||||
@ -68,8 +71,9 @@ static PyObject *python_api_get_status(PyObject *self, PyObject *args)
|
||||
{
|
||||
PyObject *ret = NULL;
|
||||
|
||||
if (!PyArg_ParseTuple(args, ""))
|
||||
if (!PyArg_ParseTuple(args, "")) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
switch (api_get_status()) {
|
||||
case TOX_USER_STATUS_NONE:
|
||||
@ -93,13 +97,15 @@ static PyObject *python_api_get_status_message(PyObject *self, PyObject *args)
|
||||
char *status;
|
||||
PyObject *ret;
|
||||
|
||||
if (!PyArg_ParseTuple(args, ""))
|
||||
if (!PyArg_ParseTuple(args, "")) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
status = api_get_status_message();
|
||||
|
||||
if (status == NULL)
|
||||
if (status == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ret = Py_BuildValue("s", status);
|
||||
free(status);
|
||||
@ -113,15 +119,17 @@ static PyObject *python_api_get_all_friends(PyObject *self, PyObject *args)
|
||||
PyObject *cur, *ret;
|
||||
char pubkey_buf[TOX_PUBLIC_KEY_SIZE * 2 + 1];
|
||||
|
||||
if (!PyArg_ParseTuple(args, ""))
|
||||
if (!PyArg_ParseTuple(args, "")) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
friends = api_get_friendslist();
|
||||
ret = PyList_New(0);
|
||||
|
||||
for (i = 0; i < friends.num_friends; i++) {
|
||||
for (ii = 0; ii < TOX_PUBLIC_KEY_SIZE; ii++)
|
||||
for (ii = 0; ii < TOX_PUBLIC_KEY_SIZE; ii++) {
|
||||
snprintf(pubkey_buf + ii * 2, 3, "%02X", friends.list[i].pub_key[ii] & 0xff);
|
||||
}
|
||||
|
||||
pubkey_buf[TOX_PUBLIC_KEY_SIZE * 2] = '\0';
|
||||
cur = Py_BuildValue("(s,s)", friends.list[i].name, pubkey_buf);
|
||||
@ -135,8 +143,9 @@ static PyObject *python_api_send(PyObject *self, PyObject *args)
|
||||
{
|
||||
const char *msg;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "s", &msg))
|
||||
if (!PyArg_ParseTuple(args, "s", &msg)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
api_send(msg);
|
||||
return Py_None;
|
||||
@ -147,8 +156,9 @@ static PyObject *python_api_execute(PyObject *self, PyObject *args)
|
||||
int mode;
|
||||
const char *command;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "si", &command, &mode))
|
||||
if (!PyArg_ParseTuple(args, "si", &command, &mode)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
api_execute(command, mode);
|
||||
return Py_None;
|
||||
@ -161,8 +171,9 @@ static PyObject *python_api_register(PyObject *self, PyObject *args)
|
||||
const char *command, *help;
|
||||
PyObject *callback;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "ssO:register_command", &command, &help, &callback))
|
||||
if (!PyArg_ParseTuple(args, "ssO:register_command", &command, &help, &callback)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!PyCallable_Check(callback)) {
|
||||
PyErr_SetString(PyExc_TypeError, "Calback parameter must be callable");
|
||||
@ -186,21 +197,24 @@ static PyObject *python_api_register(PyObject *self, PyObject *args)
|
||||
Py_XINCREF(callback);
|
||||
cur->next = malloc(sizeof(struct python_registered_func));
|
||||
|
||||
if (cur->next == NULL)
|
||||
if (cur->next == NULL) {
|
||||
return PyErr_NoMemory();
|
||||
}
|
||||
|
||||
command_len = strlen(command);
|
||||
cur->next->name = malloc(command_len + 1);
|
||||
|
||||
if (cur->next->name == NULL)
|
||||
if (cur->next->name == NULL) {
|
||||
return PyErr_NoMemory();
|
||||
}
|
||||
|
||||
strncpy(cur->next->name, command, command_len + 1);
|
||||
help_len = strlen(help);
|
||||
cur->next->help = malloc(help_len + 1);
|
||||
|
||||
if (cur->next->help == NULL)
|
||||
if (cur->next->help == NULL) {
|
||||
return PyErr_NoMemory();
|
||||
}
|
||||
|
||||
strncpy(cur->next->help, help, help_len + 1);
|
||||
cur->next->callback = callback;
|
||||
@ -252,8 +266,9 @@ void terminate_python(void)
|
||||
{
|
||||
struct python_registered_func *cur, *old;
|
||||
|
||||
if (python_commands.name != NULL)
|
||||
if (python_commands.name != NULL) {
|
||||
free(python_commands.name);
|
||||
}
|
||||
|
||||
for (cur = python_commands.next; cur != NULL;) {
|
||||
old = cur;
|
||||
@ -284,19 +299,22 @@ int do_python_command(int num_args, char (*args)[MAX_STR_SIZE])
|
||||
struct python_registered_func *cur;
|
||||
|
||||
for (cur = &python_commands; cur != NULL; cur = cur->next) {
|
||||
if (cur->name == NULL)
|
||||
if (cur->name == NULL) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!strcmp(args[0], cur->name)) {
|
||||
args_strings = PyList_New(0);
|
||||
|
||||
for (i = 1; i < num_args; i++)
|
||||
for (i = 1; i < num_args; i++) {
|
||||
PyList_Append(args_strings, Py_BuildValue("s", args[i]));
|
||||
}
|
||||
|
||||
callback_args = PyTuple_Pack(1, args_strings);
|
||||
|
||||
if (PyObject_CallObject(cur->callback, callback_args) == NULL)
|
||||
if (PyObject_CallObject(cur->callback, callback_args) == NULL) {
|
||||
api_display("Exception raised in callback function");
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -311,8 +329,9 @@ int python_num_registered_handlers(void)
|
||||
struct python_registered_func *cur;
|
||||
|
||||
for (cur = &python_commands; cur != NULL; cur = cur->next) {
|
||||
if (cur->name != NULL)
|
||||
if (cur->name != NULL) {
|
||||
n++;
|
||||
}
|
||||
}
|
||||
|
||||
return n;
|
||||
@ -340,8 +359,9 @@ void python_draw_handler_help(WINDOW *win)
|
||||
struct python_registered_func *cur;
|
||||
|
||||
for (cur = &python_commands; cur != NULL; cur = cur->next) {
|
||||
if (cur->name != NULL)
|
||||
if (cur->name != NULL) {
|
||||
wprintw(win, " %-29s: %.50s\n", cur->name, cur->help);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif /* PYTHON */
|
||||
|
@ -52,8 +52,9 @@ int ID_to_QRcode_txt(const char *tox_id, const char *outfile)
|
||||
{
|
||||
FILE *fp = fopen(outfile, "wb");
|
||||
|
||||
if (fp == NULL)
|
||||
if (fp == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
QRcode *qr_obj = QRcode_encodeString(tox_id, 0, QR_ECLEVEL_L, QR_MODE_8, 0);
|
||||
|
||||
@ -65,14 +66,16 @@ int ID_to_QRcode_txt(const char *tox_id, const char *outfile)
|
||||
size_t width = qr_obj->width;
|
||||
size_t i, j;
|
||||
|
||||
for (i = 0; i < width + BORDER_LEN * 2; ++i)
|
||||
for (i = 0; i < width + BORDER_LEN * 2; ++i) {
|
||||
fprintf(fp, "%s", CHAR_1);
|
||||
}
|
||||
|
||||
fprintf(fp, "\n");
|
||||
|
||||
for (i = 0; i < width; i += 2) {
|
||||
for (j = 0; j < BORDER_LEN; ++j)
|
||||
for (j = 0; j < BORDER_LEN; ++j) {
|
||||
fprintf(fp, "%s", CHAR_1);
|
||||
}
|
||||
|
||||
const unsigned char *row_1 = qr_obj->data + width * i;
|
||||
const unsigned char *row_2 = row_1 + width;
|
||||
@ -81,18 +84,20 @@ int ID_to_QRcode_txt(const char *tox_id, const char *outfile)
|
||||
bool x = row_1[j] & 1;
|
||||
bool y = (i + 1) < width ? (row_2[j] & 1) : false;
|
||||
|
||||
if (x && y)
|
||||
if (x && y) {
|
||||
fprintf(fp, " ");
|
||||
else if (x)
|
||||
} else if (x) {
|
||||
fprintf(fp, "%s", CHAR_2);
|
||||
else if (y)
|
||||
} else if (y) {
|
||||
fprintf(fp, "%s", CHAR_3);
|
||||
else
|
||||
} else {
|
||||
fprintf(fp, "%s", CHAR_1);
|
||||
}
|
||||
}
|
||||
|
||||
for (j = 0; j < BORDER_LEN; ++j)
|
||||
for (j = 0; j < BORDER_LEN; ++j) {
|
||||
fprintf(fp, "%s", CHAR_1);
|
||||
}
|
||||
|
||||
fprintf(fp, "\n");
|
||||
}
|
||||
|
160
src/settings.c
160
src/settings.c
@ -124,10 +124,10 @@ static void ui_defaults(struct user_settings *settings)
|
||||
snprintf(settings->line_normal, LINE_HINT_MAX + 1, "%s", LINE_NORMAL);
|
||||
|
||||
settings->mplex_away = MPLEX_ON;
|
||||
snprintf (settings->mplex_away_note,
|
||||
sizeof (settings->mplex_away_note),
|
||||
"%s",
|
||||
MPLEX_AWAY_NOTE);
|
||||
snprintf(settings->mplex_away_note,
|
||||
sizeof(settings->mplex_away_note),
|
||||
"%s",
|
||||
MPLEX_AWAY_NOTE);
|
||||
}
|
||||
|
||||
static const struct keys_strings {
|
||||
@ -253,15 +253,18 @@ static int key_parse(const char **bind)
|
||||
int len = strlen(*bind);
|
||||
|
||||
if (len > 5) {
|
||||
if (strncasecmp(*bind, "ctrl+", 5) == 0 && toupper(bind[0][5]) != 'M') /* ctrl+m cannot be used */
|
||||
if (strncasecmp(*bind, "ctrl+", 5) == 0 && toupper(bind[0][5]) != 'M') { /* ctrl+m cannot be used */
|
||||
return toupper(bind[0][5]) - 'A' + 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (strncasecmp(*bind, "tab", 3) == 0)
|
||||
if (strncasecmp(*bind, "tab", 3) == 0) {
|
||||
return T_KEY_TAB;
|
||||
}
|
||||
|
||||
if (strncasecmp(*bind, "page", 4) == 0)
|
||||
if (strncasecmp(*bind, "page", 4) == 0) {
|
||||
return len == 6 ? KEY_PPAGE : KEY_NPAGE;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
@ -304,8 +307,9 @@ int settings_load(struct user_settings *s, const char *patharg)
|
||||
if (!file_exists(path)) {
|
||||
FILE *fp = fopen(path, "w");
|
||||
|
||||
if (fp == NULL)
|
||||
if (fp == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
fclose(fp);
|
||||
}
|
||||
@ -324,18 +328,18 @@ int settings_load(struct user_settings *s, const char *patharg)
|
||||
|
||||
int time = 24;
|
||||
|
||||
if ( config_setting_lookup_int(setting, ui_strings.time_format, &time) ) {
|
||||
if (config_setting_lookup_int(setting, ui_strings.time_format, &time)) {
|
||||
if (time == 12) {
|
||||
snprintf(s->timestamp_format, sizeof(s->timestamp_format), "%s", "%I:%M:%S %p");
|
||||
snprintf(s->log_timestamp_format, sizeof(s->log_timestamp_format), "%s", "%Y/%m/%d [%I:%M:%S %p]");
|
||||
}
|
||||
}
|
||||
|
||||
if ( config_setting_lookup_string(setting, ui_strings.timestamp_format, &str) ) {
|
||||
if (config_setting_lookup_string(setting, ui_strings.timestamp_format, &str)) {
|
||||
snprintf(s->timestamp_format, sizeof(s->timestamp_format), "%s", str);
|
||||
}
|
||||
|
||||
if ( config_setting_lookup_string(setting, ui_strings.log_timestamp_format, &str) ) {
|
||||
if (config_setting_lookup_string(setting, ui_strings.log_timestamp_format, &str)) {
|
||||
snprintf(s->log_timestamp_format, sizeof(s->log_timestamp_format), "%s", str);
|
||||
}
|
||||
|
||||
@ -367,80 +371,85 @@ int settings_load(struct user_settings *s, const char *patharg)
|
||||
config_setting_lookup_int(setting, ui_strings.history_size, &s->history_size);
|
||||
config_setting_lookup_int(setting, ui_strings.nodeslist_update_freq, &s->nodeslist_update_freq);
|
||||
|
||||
if ( config_setting_lookup_string(setting, ui_strings.line_join, &str) ) {
|
||||
if (config_setting_lookup_string(setting, ui_strings.line_join, &str)) {
|
||||
snprintf(s->line_join, sizeof(s->line_join), "%s", str);
|
||||
}
|
||||
|
||||
if ( config_setting_lookup_string(setting, ui_strings.line_quit, &str) ) {
|
||||
if (config_setting_lookup_string(setting, ui_strings.line_quit, &str)) {
|
||||
snprintf(s->line_quit, sizeof(s->line_quit), "%s", str);
|
||||
}
|
||||
|
||||
if ( config_setting_lookup_string(setting, ui_strings.line_alert, &str) ) {
|
||||
if (config_setting_lookup_string(setting, ui_strings.line_alert, &str)) {
|
||||
snprintf(s->line_alert, sizeof(s->line_alert), "%s", str);
|
||||
}
|
||||
|
||||
if ( config_setting_lookup_string(setting, ui_strings.line_normal, &str) ) {
|
||||
if (config_setting_lookup_string(setting, ui_strings.line_normal, &str)) {
|
||||
snprintf(s->line_normal, sizeof(s->line_normal), "%s", str);
|
||||
}
|
||||
|
||||
config_setting_lookup_bool (setting, ui_strings.mplex_away, &s->mplex_away);
|
||||
config_setting_lookup_bool(setting, ui_strings.mplex_away, &s->mplex_away);
|
||||
|
||||
if (config_setting_lookup_string (setting, ui_strings.mplex_away_note, &str)) {
|
||||
snprintf (s->mplex_away_note, sizeof (s->mplex_away_note), "%s", str);
|
||||
if (config_setting_lookup_string(setting, ui_strings.mplex_away_note, &str)) {
|
||||
snprintf(s->mplex_away_note, sizeof(s->mplex_away_note), "%s", str);
|
||||
}
|
||||
}
|
||||
|
||||
/* paths */
|
||||
if ((setting = config_lookup(cfg, tox_strings.self)) != NULL) {
|
||||
if ( config_setting_lookup_string(setting, tox_strings.download_path, &str) ) {
|
||||
if (config_setting_lookup_string(setting, tox_strings.download_path, &str)) {
|
||||
snprintf(s->download_path, sizeof(s->download_path), "%s", str);
|
||||
int len = strlen(s->download_path);
|
||||
|
||||
/* make sure path ends with a '/' */
|
||||
if (len >= sizeof(s->download_path) - 2)
|
||||
if (len >= sizeof(s->download_path) - 2) {
|
||||
s->download_path[0] = '\0';
|
||||
else if (s->download_path[len - 1] != '/')
|
||||
} else if (s->download_path[len - 1] != '/') {
|
||||
strcat(&s->download_path[len - 1], "/");
|
||||
}
|
||||
}
|
||||
|
||||
if ( config_setting_lookup_string(setting, tox_strings.chatlogs_path, &str) ) {
|
||||
if (config_setting_lookup_string(setting, tox_strings.chatlogs_path, &str)) {
|
||||
snprintf(s->chatlogs_path, sizeof(s->chatlogs_path), "%s", str);
|
||||
int len = strlen(s->chatlogs_path);
|
||||
|
||||
if (len >= sizeof(s->chatlogs_path) - 2)
|
||||
if (len >= sizeof(s->chatlogs_path) - 2) {
|
||||
s->chatlogs_path[0] = '\0';
|
||||
else if (s->chatlogs_path[len - 1] != '/')
|
||||
} else if (s->chatlogs_path[len - 1] != '/') {
|
||||
strcat(&s->chatlogs_path[len - 1], "/");
|
||||
}
|
||||
}
|
||||
|
||||
if ( config_setting_lookup_string(setting, tox_strings.avatar_path, &str) ) {
|
||||
if (config_setting_lookup_string(setting, tox_strings.avatar_path, &str)) {
|
||||
snprintf(s->avatar_path, sizeof(s->avatar_path), "%s", str);
|
||||
int len = strlen(str);
|
||||
|
||||
if (len >= sizeof(s->avatar_path))
|
||||
if (len >= sizeof(s->avatar_path)) {
|
||||
s->avatar_path[0] = '\0';
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef PYTHON
|
||||
|
||||
if ( config_setting_lookup_string(setting, tox_strings.autorun_path, &str) ) {
|
||||
if (config_setting_lookup_string(setting, tox_strings.autorun_path, &str)) {
|
||||
snprintf(s->autorun_path, sizeof(s->autorun_path), "%s", str);
|
||||
int len = strlen(str);
|
||||
|
||||
if (len >= sizeof(s->autorun_path) - 2)
|
||||
if (len >= sizeof(s->autorun_path) - 2) {
|
||||
s->autorun_path[0] = '\0';
|
||||
else if (s->autorun_path[len - 1] != '/')
|
||||
} else if (s->autorun_path[len - 1] != '/') {
|
||||
strcat(&s->autorun_path[len - 1], "/");
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
if ( config_setting_lookup_string(setting, tox_strings.password_eval, &str) ) {
|
||||
if (config_setting_lookup_string(setting, tox_strings.password_eval, &str)) {
|
||||
snprintf(s->password_eval, sizeof(s->password_eval), "%s", str);
|
||||
int len = strlen(str);
|
||||
|
||||
if (len >= sizeof(s->password_eval))
|
||||
if (len >= sizeof(s->password_eval)) {
|
||||
s->password_eval[0] = '\0';
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -448,38 +457,49 @@ int settings_load(struct user_settings *s, const char *patharg)
|
||||
if ((setting = config_lookup(cfg, key_strings.self)) != NULL) {
|
||||
const char *tmp = NULL;
|
||||
|
||||
if (config_setting_lookup_string(setting, key_strings.next_tab, &tmp))
|
||||
if (config_setting_lookup_string(setting, key_strings.next_tab, &tmp)) {
|
||||
set_key_binding(&s->key_next_tab, &tmp);
|
||||
}
|
||||
|
||||
if (config_setting_lookup_string(setting, key_strings.prev_tab, &tmp))
|
||||
if (config_setting_lookup_string(setting, key_strings.prev_tab, &tmp)) {
|
||||
set_key_binding(&s->key_prev_tab, &tmp);
|
||||
}
|
||||
|
||||
if (config_setting_lookup_string(setting, key_strings.scroll_line_up, &tmp))
|
||||
if (config_setting_lookup_string(setting, key_strings.scroll_line_up, &tmp)) {
|
||||
set_key_binding(&s->key_scroll_line_up, &tmp);
|
||||
}
|
||||
|
||||
if (config_setting_lookup_string(setting, key_strings.scroll_line_down, &tmp))
|
||||
if (config_setting_lookup_string(setting, key_strings.scroll_line_down, &tmp)) {
|
||||
set_key_binding(&s->key_scroll_line_down, &tmp);
|
||||
}
|
||||
|
||||
if (config_setting_lookup_string(setting, key_strings.half_page_up, &tmp))
|
||||
if (config_setting_lookup_string(setting, key_strings.half_page_up, &tmp)) {
|
||||
set_key_binding(&s->key_half_page_up, &tmp);
|
||||
}
|
||||
|
||||
if (config_setting_lookup_string(setting, key_strings.half_page_down, &tmp))
|
||||
if (config_setting_lookup_string(setting, key_strings.half_page_down, &tmp)) {
|
||||
set_key_binding(&s->key_half_page_down, &tmp);
|
||||
}
|
||||
|
||||
if (config_setting_lookup_string(setting, key_strings.page_bottom, &tmp))
|
||||
if (config_setting_lookup_string(setting, key_strings.page_bottom, &tmp)) {
|
||||
set_key_binding(&s->key_page_bottom, &tmp);
|
||||
}
|
||||
|
||||
if (config_setting_lookup_string(setting, key_strings.peer_list_up, &tmp))
|
||||
if (config_setting_lookup_string(setting, key_strings.peer_list_up, &tmp)) {
|
||||
set_key_binding(&s->key_peer_list_up, &tmp);
|
||||
}
|
||||
|
||||
if (config_setting_lookup_string(setting, key_strings.peer_list_down, &tmp))
|
||||
if (config_setting_lookup_string(setting, key_strings.peer_list_down, &tmp)) {
|
||||
set_key_binding(&s->key_peer_list_down, &tmp);
|
||||
}
|
||||
|
||||
if (config_setting_lookup_string(setting, key_strings.toggle_peerlist, &tmp))
|
||||
if (config_setting_lookup_string(setting, key_strings.toggle_peerlist, &tmp)) {
|
||||
set_key_binding(&s->key_toggle_peerlist, &tmp);
|
||||
}
|
||||
|
||||
if (config_setting_lookup_string(setting, key_strings.toggle_pastemode, &tmp))
|
||||
if (config_setting_lookup_string(setting, key_strings.toggle_pastemode, &tmp)) {
|
||||
set_key_binding(&s->key_toggle_pastemode, &tmp);
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef AUDIO
|
||||
@ -499,52 +519,60 @@ int settings_load(struct user_settings *s, const char *patharg)
|
||||
#ifdef SOUND_NOTIFY
|
||||
|
||||
if ((setting = config_lookup(cfg, sound_strings.self)) != NULL) {
|
||||
if ( (config_setting_lookup_string(setting, sound_strings.notif_error, &str) != CONFIG_TRUE) ||
|
||||
!set_sound(notif_error, str) ) {
|
||||
if (str && strcasecmp(str, NO_SOUND) != 0)
|
||||
if ((config_setting_lookup_string(setting, sound_strings.notif_error, &str) != CONFIG_TRUE) ||
|
||||
!set_sound(notif_error, str)) {
|
||||
if (str && strcasecmp(str, NO_SOUND) != 0) {
|
||||
set_sound(notif_error, PACKAGE_DATADIR "/sounds/ToxicError.wav");
|
||||
}
|
||||
}
|
||||
|
||||
if ( !config_setting_lookup_string(setting, sound_strings.user_log_in, &str) ||
|
||||
!set_sound(user_log_in, str) ) {
|
||||
if (str && strcasecmp(str, NO_SOUND) != 0)
|
||||
if (!config_setting_lookup_string(setting, sound_strings.user_log_in, &str) ||
|
||||
!set_sound(user_log_in, str)) {
|
||||
if (str && strcasecmp(str, NO_SOUND) != 0) {
|
||||
set_sound(user_log_in, PACKAGE_DATADIR "/sounds/ToxicContactOnline.wav");
|
||||
}
|
||||
}
|
||||
|
||||
if ( !config_setting_lookup_string(setting, sound_strings.user_log_out, &str) ||
|
||||
!set_sound(user_log_out, str) ) {
|
||||
if (str && strcasecmp(str, NO_SOUND) != 0)
|
||||
if (!config_setting_lookup_string(setting, sound_strings.user_log_out, &str) ||
|
||||
!set_sound(user_log_out, str)) {
|
||||
if (str && strcasecmp(str, NO_SOUND) != 0) {
|
||||
set_sound(user_log_out, PACKAGE_DATADIR "/sounds/ToxicContactOffline.wav");
|
||||
}
|
||||
}
|
||||
|
||||
if ( !config_setting_lookup_string(setting, sound_strings.call_incoming, &str) ||
|
||||
!set_sound(call_incoming, str) ) {
|
||||
if (str && strcasecmp(str, NO_SOUND) != 0)
|
||||
if (!config_setting_lookup_string(setting, sound_strings.call_incoming, &str) ||
|
||||
!set_sound(call_incoming, str)) {
|
||||
if (str && strcasecmp(str, NO_SOUND) != 0) {
|
||||
set_sound(call_incoming, PACKAGE_DATADIR "/sounds/ToxicIncomingCall.wav");
|
||||
}
|
||||
}
|
||||
|
||||
if ( !config_setting_lookup_string(setting, sound_strings.call_outgoing, &str) ||
|
||||
!set_sound(call_outgoing, str) ) {
|
||||
if (str && strcasecmp(str, NO_SOUND) != 0)
|
||||
if (!config_setting_lookup_string(setting, sound_strings.call_outgoing, &str) ||
|
||||
!set_sound(call_outgoing, str)) {
|
||||
if (str && strcasecmp(str, NO_SOUND) != 0) {
|
||||
set_sound(call_outgoing, PACKAGE_DATADIR "/sounds/ToxicOutgoingCall.wav");
|
||||
}
|
||||
}
|
||||
|
||||
if ( !config_setting_lookup_string(setting, sound_strings.generic_message, &str) ||
|
||||
!set_sound(generic_message, str) ) {
|
||||
if (str && strcasecmp(str, NO_SOUND) != 0)
|
||||
if (!config_setting_lookup_string(setting, sound_strings.generic_message, &str) ||
|
||||
!set_sound(generic_message, str)) {
|
||||
if (str && strcasecmp(str, NO_SOUND) != 0) {
|
||||
set_sound(generic_message, PACKAGE_DATADIR "/sounds/ToxicRecvMessage.wav");
|
||||
}
|
||||
}
|
||||
|
||||
if ( !config_setting_lookup_string(setting, sound_strings.transfer_pending, &str) ||
|
||||
!set_sound(transfer_pending, str) ) {
|
||||
if (str && strcasecmp(str, NO_SOUND) != 0)
|
||||
if (!config_setting_lookup_string(setting, sound_strings.transfer_pending, &str) ||
|
||||
!set_sound(transfer_pending, str)) {
|
||||
if (str && strcasecmp(str, NO_SOUND) != 0) {
|
||||
set_sound(transfer_pending, PACKAGE_DATADIR "/sounds/ToxicTransferStart.wav");
|
||||
}
|
||||
}
|
||||
|
||||
if ( !config_setting_lookup_string(setting, sound_strings.transfer_completed, &str) ||
|
||||
!set_sound(transfer_completed, str) ) {
|
||||
if (str && strcasecmp(str, NO_SOUND) != 0)
|
||||
if (!config_setting_lookup_string(setting, sound_strings.transfer_completed, &str) ||
|
||||
!set_sound(transfer_completed, str)) {
|
||||
if (str && strcasecmp(str, NO_SOUND) != 0) {
|
||||
set_sound(transfer_completed, PACKAGE_DATADIR "/sounds/ToxicTransferComplete.wav");
|
||||
}
|
||||
}
|
||||
} else {
|
||||
set_sound(notif_error, PACKAGE_DATADIR "/sounds/ToxicError.wav");
|
||||
|
243
src/term_mplex.c
243
src/term_mplex.c
@ -80,108 +80,118 @@ static char prev_note [TOX_MAX_STATUS_MESSAGE_LENGTH] = "";
|
||||
static pthread_mutex_t status_lock;
|
||||
static pthread_t mplex_tid;
|
||||
|
||||
void lock_status ()
|
||||
void lock_status()
|
||||
{
|
||||
pthread_mutex_lock (&status_lock);
|
||||
pthread_mutex_lock(&status_lock);
|
||||
}
|
||||
|
||||
void unlock_status ()
|
||||
void unlock_status()
|
||||
{
|
||||
pthread_mutex_unlock (&status_lock);
|
||||
pthread_mutex_unlock(&status_lock);
|
||||
}
|
||||
|
||||
static char *read_into_dyn_buffer (FILE *stream)
|
||||
static char *read_into_dyn_buffer(FILE *stream)
|
||||
{
|
||||
const char *input_ptr = NULL;
|
||||
char *dyn_buffer = NULL;
|
||||
int dyn_buffer_size = 1; /* account for the \0 */
|
||||
|
||||
while ((input_ptr = fgets (buffer, BUFFER_SIZE, stream)) != NULL) {
|
||||
int length = dyn_buffer_size + strlen (input_ptr);
|
||||
while ((input_ptr = fgets(buffer, BUFFER_SIZE, stream)) != NULL) {
|
||||
int length = dyn_buffer_size + strlen(input_ptr);
|
||||
|
||||
if (dyn_buffer)
|
||||
dyn_buffer = (char *) realloc (dyn_buffer, length);
|
||||
else
|
||||
dyn_buffer = (char *) malloc (length);
|
||||
if (dyn_buffer) {
|
||||
dyn_buffer = (char *) realloc(dyn_buffer, length);
|
||||
} else {
|
||||
dyn_buffer = (char *) malloc(length);
|
||||
}
|
||||
|
||||
strcpy (dyn_buffer + dyn_buffer_size - 1, input_ptr);
|
||||
strcpy(dyn_buffer + dyn_buffer_size - 1, input_ptr);
|
||||
dyn_buffer_size = length;
|
||||
}
|
||||
|
||||
return dyn_buffer;
|
||||
}
|
||||
|
||||
static char *extract_socket_path (const char *info)
|
||||
static char *extract_socket_path(const char *info)
|
||||
{
|
||||
const char *search_str = " Socket";
|
||||
const char *pos = strstr (info, search_str);
|
||||
const char *pos = strstr(info, search_str);
|
||||
char *end = NULL;
|
||||
char *path = NULL;
|
||||
|
||||
if (!pos)
|
||||
if (!pos) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
pos += strlen (search_str);
|
||||
pos = strchr (pos, PATH_SEP_C);
|
||||
pos += strlen(search_str);
|
||||
pos = strchr(pos, PATH_SEP_C);
|
||||
|
||||
if (!pos)
|
||||
if (!pos) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
end = strchr (pos, '\n');
|
||||
end = strchr(pos, '\n');
|
||||
|
||||
if (!end)
|
||||
if (!end) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
*end = '\0';
|
||||
end = strrchr (pos, '.');
|
||||
end = strrchr(pos, '.');
|
||||
|
||||
if (!end)
|
||||
if (!end) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
path = (char *) malloc (end - pos + 1);
|
||||
path = (char *) malloc(end - pos + 1);
|
||||
*end = '\0';
|
||||
return strcpy (path, pos);
|
||||
return strcpy(path, pos);
|
||||
}
|
||||
|
||||
static int detect_gnu_screen ()
|
||||
static int detect_gnu_screen()
|
||||
{
|
||||
FILE *session_info_stream = NULL;
|
||||
char *socket_name = NULL, *socket_path = NULL;
|
||||
char *dyn_buffer = NULL;
|
||||
|
||||
socket_name = getenv ("STY");
|
||||
socket_name = getenv("STY");
|
||||
|
||||
if (!socket_name)
|
||||
if (!socket_name) {
|
||||
goto nomplex;
|
||||
}
|
||||
|
||||
session_info_stream = popen ("env LC_ALL=C screen -ls", "r");
|
||||
session_info_stream = popen("env LC_ALL=C screen -ls", "r");
|
||||
|
||||
if (!session_info_stream)
|
||||
if (!session_info_stream) {
|
||||
goto nomplex;
|
||||
}
|
||||
|
||||
dyn_buffer = read_into_dyn_buffer (session_info_stream);
|
||||
dyn_buffer = read_into_dyn_buffer(session_info_stream);
|
||||
|
||||
if (!dyn_buffer)
|
||||
if (!dyn_buffer) {
|
||||
goto nomplex;
|
||||
}
|
||||
|
||||
pclose (session_info_stream);
|
||||
pclose(session_info_stream);
|
||||
session_info_stream = NULL;
|
||||
|
||||
socket_path = extract_socket_path (dyn_buffer);
|
||||
socket_path = extract_socket_path(dyn_buffer);
|
||||
|
||||
if (!socket_path)
|
||||
if (!socket_path) {
|
||||
goto nomplex;
|
||||
}
|
||||
|
||||
free (dyn_buffer);
|
||||
free(dyn_buffer);
|
||||
dyn_buffer = NULL;
|
||||
|
||||
if (strlen(socket_path) + strlen(PATH_SEP_S) + strlen(socket_name) >= sizeof(mplex_data))
|
||||
if (strlen(socket_path) + strlen(PATH_SEP_S) + strlen(socket_name) >= sizeof(mplex_data)) {
|
||||
goto nomplex;
|
||||
}
|
||||
|
||||
strcpy (mplex_data, socket_path);
|
||||
strcat (mplex_data, PATH_SEP_S);
|
||||
strcat (mplex_data, socket_name);
|
||||
free (socket_path);
|
||||
strcpy(mplex_data, socket_path);
|
||||
strcat(mplex_data, PATH_SEP_S);
|
||||
strcat(mplex_data, socket_name);
|
||||
free(socket_path);
|
||||
socket_path = NULL;
|
||||
|
||||
mplex = MPLEX_SCREEN;
|
||||
@ -189,33 +199,38 @@ static int detect_gnu_screen ()
|
||||
|
||||
nomplex:
|
||||
|
||||
if (session_info_stream)
|
||||
pclose (session_info_stream);
|
||||
if (session_info_stream) {
|
||||
pclose(session_info_stream);
|
||||
}
|
||||
|
||||
if (dyn_buffer)
|
||||
free (dyn_buffer);
|
||||
if (dyn_buffer) {
|
||||
free(dyn_buffer);
|
||||
}
|
||||
|
||||
if (socket_path)
|
||||
if (socket_path) {
|
||||
free(socket_path);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int detect_tmux ()
|
||||
static int detect_tmux()
|
||||
{
|
||||
char *tmux_env = getenv ("TMUX"), *pos;
|
||||
char *tmux_env = getenv("TMUX"), *pos;
|
||||
|
||||
if (!tmux_env)
|
||||
if (!tmux_env) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* find second separator */
|
||||
pos = strrchr (tmux_env, ',');
|
||||
pos = strrchr(tmux_env, ',');
|
||||
|
||||
if (!pos)
|
||||
if (!pos) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* store the session id for later use */
|
||||
snprintf (mplex_data, sizeof(mplex_data), "$%s", pos + 1);
|
||||
snprintf(mplex_data, sizeof(mplex_data), "$%s", pos + 1);
|
||||
mplex = MPLEX_TMUX;
|
||||
return 1;
|
||||
}
|
||||
@ -228,92 +243,102 @@ static int detect_tmux ()
|
||||
Returns 1 if present, 0 otherwise. This value can be used to determine
|
||||
whether an auto-away detection timer is needed.
|
||||
*/
|
||||
static int detect_mplex ()
|
||||
static int detect_mplex()
|
||||
{
|
||||
/* try screen, and if fails try tmux */
|
||||
return detect_gnu_screen () || detect_tmux ();
|
||||
return detect_gnu_screen() || detect_tmux();
|
||||
}
|
||||
|
||||
/* Detects gnu screen session attached/detached by examining permissions of
|
||||
the session's unix socket.
|
||||
*/
|
||||
static int gnu_screen_is_detached ()
|
||||
static int gnu_screen_is_detached()
|
||||
{
|
||||
if (mplex != MPLEX_SCREEN)
|
||||
if (mplex != MPLEX_SCREEN) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct stat sb;
|
||||
|
||||
if (stat (mplex_data, &sb) != 0)
|
||||
if (stat(mplex_data, &sb) != 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* execution permission (x) means attached */
|
||||
return ! (sb.st_mode & S_IXUSR);
|
||||
return !(sb.st_mode & S_IXUSR);
|
||||
}
|
||||
|
||||
/* Detects tmux attached/detached by getting session data and finding the
|
||||
current session's entry.
|
||||
*/
|
||||
static int tmux_is_detached ()
|
||||
static int tmux_is_detached()
|
||||
{
|
||||
if (mplex != MPLEX_TMUX)
|
||||
if (mplex != MPLEX_TMUX) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
FILE *session_info_stream = NULL;
|
||||
char *dyn_buffer = NULL, *search_str = NULL;
|
||||
char *entry_pos;
|
||||
int detached;
|
||||
const int numstr_len = strlen (mplex_data);
|
||||
const int numstr_len = strlen(mplex_data);
|
||||
|
||||
/* get the number of attached clients for each session */
|
||||
session_info_stream = popen ("tmux list-sessions -F \"#{session_id} #{session_attached}\"", "r");
|
||||
session_info_stream = popen("tmux list-sessions -F \"#{session_id} #{session_attached}\"", "r");
|
||||
|
||||
if (!session_info_stream)
|
||||
if (!session_info_stream) {
|
||||
goto fail;
|
||||
}
|
||||
|
||||
dyn_buffer = read_into_dyn_buffer (session_info_stream);
|
||||
dyn_buffer = read_into_dyn_buffer(session_info_stream);
|
||||
|
||||
if (!dyn_buffer)
|
||||
if (!dyn_buffer) {
|
||||
goto fail;
|
||||
}
|
||||
|
||||
pclose (session_info_stream);
|
||||
pclose(session_info_stream);
|
||||
session_info_stream = NULL;
|
||||
|
||||
/* prepare search string, for finding the current session's entry */
|
||||
search_str = (char *) malloc (numstr_len + 2);
|
||||
search_str = (char *) malloc(numstr_len + 2);
|
||||
search_str[0] = '\n';
|
||||
strcpy (search_str + 1, mplex_data);
|
||||
strcpy(search_str + 1, mplex_data);
|
||||
|
||||
/* do the search */
|
||||
if (strncmp (dyn_buffer, search_str + 1, numstr_len) == 0)
|
||||
if (strncmp(dyn_buffer, search_str + 1, numstr_len) == 0) {
|
||||
entry_pos = dyn_buffer;
|
||||
else
|
||||
entry_pos = strstr (dyn_buffer, search_str);
|
||||
} else {
|
||||
entry_pos = strstr(dyn_buffer, search_str);
|
||||
}
|
||||
|
||||
if (! entry_pos)
|
||||
if (! entry_pos) {
|
||||
goto fail;
|
||||
}
|
||||
|
||||
entry_pos = strchr (entry_pos, ' ') + 1;
|
||||
detached = strncmp (entry_pos, "0\n", 2) == 0;
|
||||
entry_pos = strchr(entry_pos, ' ') + 1;
|
||||
detached = strncmp(entry_pos, "0\n", 2) == 0;
|
||||
|
||||
free (search_str);
|
||||
free(search_str);
|
||||
search_str = NULL;
|
||||
|
||||
free (dyn_buffer);
|
||||
free(dyn_buffer);
|
||||
dyn_buffer = NULL;
|
||||
|
||||
return detached;
|
||||
|
||||
fail:
|
||||
|
||||
if (session_info_stream)
|
||||
pclose (session_info_stream);
|
||||
if (session_info_stream) {
|
||||
pclose(session_info_stream);
|
||||
}
|
||||
|
||||
if (dyn_buffer)
|
||||
free (dyn_buffer);
|
||||
if (dyn_buffer) {
|
||||
free(dyn_buffer);
|
||||
}
|
||||
|
||||
if (search_str)
|
||||
free (search_str);
|
||||
if (search_str) {
|
||||
free(search_str);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -327,24 +352,25 @@ fail:
|
||||
sample its state and update away status according to attached/detached state
|
||||
of the mplex.
|
||||
*/
|
||||
static int mplex_is_detached ()
|
||||
static int mplex_is_detached()
|
||||
{
|
||||
return gnu_screen_is_detached () || tmux_is_detached ();
|
||||
return gnu_screen_is_detached() || tmux_is_detached();
|
||||
}
|
||||
|
||||
static void mplex_timer_handler (Tox *m)
|
||||
static void mplex_timer_handler(Tox *m)
|
||||
{
|
||||
TOX_USER_STATUS current_status, new_status;
|
||||
const char *new_note;
|
||||
|
||||
if (mplex == MPLEX_NONE)
|
||||
if (mplex == MPLEX_NONE) {
|
||||
return;
|
||||
}
|
||||
|
||||
int detached = mplex_is_detached ();
|
||||
int detached = mplex_is_detached();
|
||||
|
||||
pthread_mutex_lock (&Winthread.lock);
|
||||
current_status = tox_self_get_status (m);
|
||||
pthread_mutex_unlock (&Winthread.lock);
|
||||
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;
|
||||
@ -354,25 +380,26 @@ static void mplex_timer_handler (Tox *m)
|
||||
auto_away_active = true;
|
||||
prev_status = current_status;
|
||||
new_status = TOX_USER_STATUS_AWAY;
|
||||
pthread_mutex_lock (&Winthread.lock);
|
||||
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);
|
||||
tox_self_get_status_message(m, (uint8_t *) prev_note);
|
||||
prev_note[slen] = '\0';
|
||||
pthread_mutex_unlock (&Winthread.lock);
|
||||
pthread_mutex_unlock(&Winthread.lock);
|
||||
new_note = user_settings->mplex_away_note;
|
||||
} else
|
||||
} 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"));
|
||||
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);
|
||||
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);
|
||||
}
|
||||
|
||||
/* Time in seconds between calls to mplex_timer_handler */
|
||||
@ -388,20 +415,24 @@ void *mplex_timer_thread(void *data)
|
||||
}
|
||||
}
|
||||
|
||||
int init_mplex_away_timer (Tox *m)
|
||||
int init_mplex_away_timer(Tox *m)
|
||||
{
|
||||
if (! detect_mplex ())
|
||||
if (! detect_mplex()) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (! user_settings->mplex_away)
|
||||
if (! user_settings->mplex_away) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* status access mutex */
|
||||
if (pthread_mutex_init (&status_lock, NULL) != 0)
|
||||
if (pthread_mutex_init(&status_lock, NULL) != 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (pthread_create(&mplex_tid, NULL, mplex_timer_thread, (void *) m) != 0)
|
||||
if (pthread_create(&mplex_tid, NULL, mplex_timer_thread, (void *) m) != 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -27,9 +27,9 @@
|
||||
yes, it initializes a timer which periodically checks the attached/detached
|
||||
state of the terminal and updates away status accordingly.
|
||||
*/
|
||||
int init_mplex_away_timer (Tox *m);
|
||||
int init_mplex_away_timer(Tox *m);
|
||||
|
||||
void lock_status ();
|
||||
void unlock_status ();
|
||||
void lock_status();
|
||||
void unlock_status();
|
||||
|
||||
#endif /* #define TERM_MPLEX_H */
|
||||
|
175
src/toxic.c
175
src/toxic.c
@ -229,8 +229,9 @@ static void init_term(void)
|
||||
start_color();
|
||||
|
||||
if (user_settings->colour_theme == NATIVE_COLS) {
|
||||
if (assume_default_colors(-1, -1) == OK)
|
||||
if (assume_default_colors(-1, -1) == OK) {
|
||||
bg_color = -1;
|
||||
}
|
||||
}
|
||||
|
||||
init_pair(0, COLOR_WHITE, COLOR_BLACK);
|
||||
@ -267,13 +268,15 @@ static void queue_init_message(const char *msg, ...)
|
||||
|
||||
char **new_msgs = realloc(init_messages.msgs, sizeof(char *) * init_messages.num);
|
||||
|
||||
if (new_msgs == NULL)
|
||||
if (new_msgs == NULL) {
|
||||
exit_toxic_err("Failed in queue_init_message", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
new_msgs[i] = malloc(MAX_STR_SIZE);
|
||||
|
||||
if (new_msgs[i] == NULL)
|
||||
if (new_msgs[i] == NULL) {
|
||||
exit_toxic_err("Failed in queue_init_message", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
snprintf(new_msgs[i], MAX_STR_SIZE, "%s", frmt_msg);
|
||||
init_messages.msgs = new_msgs;
|
||||
@ -282,13 +285,15 @@ static void queue_init_message(const char *msg, ...)
|
||||
/* called after messages have been printed to prompt and are no longer needed */
|
||||
static void cleanup_init_messages(void)
|
||||
{
|
||||
if (init_messages.num <= 0)
|
||||
if (init_messages.num <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
int i;
|
||||
|
||||
for (i = 0; i < init_messages.num; ++i)
|
||||
for (i = 0; i < init_messages.num; ++i) {
|
||||
free(init_messages.msgs[i]);
|
||||
}
|
||||
|
||||
free(init_messages.msgs);
|
||||
}
|
||||
@ -297,8 +302,9 @@ static void print_init_messages(ToxWindow *toxwin)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < init_messages.num; ++i)
|
||||
for (i = 0; i < init_messages.num; ++i) {
|
||||
line_info_add(toxwin, NULL, NULL, NULL, SYS_MSG, 0, 0, init_messages.msgs[i]);
|
||||
}
|
||||
}
|
||||
|
||||
static void load_friendlist(Tox *m)
|
||||
@ -358,8 +364,9 @@ static int password_prompt(char *buf, int size)
|
||||
nflags.c_lflag &= ~ECHO;
|
||||
nflags.c_lflag |= ECHONL;
|
||||
|
||||
if (tcsetattr(fileno(stdin), TCSANOW, &nflags) != 0)
|
||||
if (tcsetattr(fileno(stdin), TCSANOW, &nflags) != 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
const char *p = fgets(buf, size, stdin);
|
||||
int len = strlen(buf);
|
||||
@ -367,8 +374,9 @@ static int password_prompt(char *buf, int size)
|
||||
/* re-enable terminal echo */
|
||||
tcsetattr(fileno(stdin), TCSANOW, &oflags);
|
||||
|
||||
if (p == NULL || len <= 1)
|
||||
if (p == NULL || len <= 1) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* eat overflowed stdin and return error */
|
||||
if (buf[--len] != '\n') {
|
||||
@ -438,15 +446,17 @@ static void first_time_encrypt(const char *msg)
|
||||
fflush(stdout);
|
||||
|
||||
if (!strcasecmp(ch, "y\n") || !strcasecmp(ch, "n\n") || !strcasecmp(ch, "yes\n")
|
||||
|| !strcasecmp(ch, "no\n") || !strcasecmp(ch, "q\n"))
|
||||
|| !strcasecmp(ch, "no\n") || !strcasecmp(ch, "q\n")) {
|
||||
break;
|
||||
}
|
||||
|
||||
} while (fgets(ch, sizeof(ch), stdin));
|
||||
|
||||
printf("\n");
|
||||
|
||||
if (ch[0] == 'q' || ch[0] == 'Q')
|
||||
if (ch[0] == 'q' || ch[0] == 'Q') {
|
||||
exit(0);
|
||||
}
|
||||
|
||||
if (ch[0] == 'y' || ch[0] == 'Y') {
|
||||
int len = 0;
|
||||
@ -460,8 +470,9 @@ static void first_time_encrypt(const char *msg)
|
||||
len = password_prompt(user_password.pass, sizeof(user_password.pass));
|
||||
user_password.len = len;
|
||||
|
||||
if (strcasecmp(user_password.pass, "q") == 0)
|
||||
if (strcasecmp(user_password.pass, "q") == 0) {
|
||||
exit(0);
|
||||
}
|
||||
|
||||
if (string_is_empty(passconfirm) && (len < MIN_PASSWORD_LEN || len > MAX_PASSWORD_LEN)) {
|
||||
printf("Password must be between %d and %d characters long. ", MIN_PASSWORD_LEN, MAX_PASSWORD_LEN);
|
||||
@ -604,11 +615,13 @@ static void init_tox_options(struct Tox_Options *tox_opts)
|
||||
tox_options_set_proxy_type(tox_opts, arg_opts.proxy_type);
|
||||
tox_options_set_tcp_port(tox_opts, arg_opts.tcp_port);
|
||||
|
||||
if (!tox_options_get_ipv6_enabled(tox_opts))
|
||||
if (!tox_options_get_ipv6_enabled(tox_opts)) {
|
||||
queue_init_message("Forcing IPv4 connection");
|
||||
}
|
||||
|
||||
if (tox_options_get_tcp_port(tox_opts))
|
||||
if (tox_options_get_tcp_port(tox_opts)) {
|
||||
queue_init_message("TCP relaying enabled on port %d", tox_options_get_tcp_port(tox_opts));
|
||||
}
|
||||
|
||||
if (tox_options_get_proxy_type(tox_opts) != TOX_PROXY_TYPE_NONE) {
|
||||
tox_options_set_proxy_port(tox_opts, arg_opts.proxy_port);
|
||||
@ -662,14 +675,16 @@ static Tox *load_tox(char *data_path, struct Tox_Options *tox_opts, TOX_ERR_NEW
|
||||
exit_toxic_err("failed in load_tox", FATALERR_ENCRYPT);
|
||||
}
|
||||
|
||||
if (arg_opts.unencrypt_data && is_encrypted)
|
||||
if (arg_opts.unencrypt_data && is_encrypted) {
|
||||
queue_init_message("Data file '%s' has been unencrypted", data_path);
|
||||
else if (arg_opts.unencrypt_data)
|
||||
} else if (arg_opts.unencrypt_data) {
|
||||
queue_init_message("Warning: passed --unencrypt-data option with unencrypted data file '%s'", data_path);
|
||||
}
|
||||
|
||||
if (is_encrypted) {
|
||||
if (!arg_opts.unencrypt_data)
|
||||
if (!arg_opts.unencrypt_data) {
|
||||
user_password.data_is_encrypted = true;
|
||||
}
|
||||
|
||||
size_t pwlen = 0;
|
||||
int pweval = user_settings->password_eval[0];
|
||||
@ -746,18 +761,21 @@ static Tox *load_tox(char *data_path, struct Tox_Options *tox_opts, TOX_ERR_NEW
|
||||
|
||||
fclose(fp);
|
||||
} else { /* Data file does not/should not exist */
|
||||
if (file_exists(data_path))
|
||||
if (file_exists(data_path)) {
|
||||
exit_toxic_err("failed in load_tox", FATALERR_FILEOP);
|
||||
}
|
||||
|
||||
tox_options_set_savedata_type(tox_opts, TOX_SAVEDATA_TYPE_NONE);
|
||||
|
||||
m = tox_new(tox_opts, new_err);
|
||||
|
||||
if (m == NULL)
|
||||
if (m == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (store_data(m, data_path) == -1)
|
||||
if (store_data(m, data_path) == -1) {
|
||||
exit_toxic_err("failed in load_tox", FATALERR_FILEOP);
|
||||
}
|
||||
}
|
||||
|
||||
return m;
|
||||
@ -768,8 +786,9 @@ static Tox *load_toxic(char *data_path)
|
||||
TOX_ERR_OPTIONS_NEW options_new_err;
|
||||
struct Tox_Options *tox_opts = tox_options_new(&options_new_err);
|
||||
|
||||
if (!tox_opts)
|
||||
if (!tox_opts) {
|
||||
exit_toxic_err("tox_options_new returned fatal error", options_new_err);
|
||||
}
|
||||
|
||||
init_tox_options(tox_opts);
|
||||
|
||||
@ -782,18 +801,21 @@ static Tox *load_toxic(char *data_path)
|
||||
m = load_tox(data_path, tox_opts, &new_err);
|
||||
}
|
||||
|
||||
if (!m)
|
||||
if (!m) {
|
||||
exit_toxic_err("tox_new returned fatal error", new_err);
|
||||
}
|
||||
|
||||
if (new_err != TOX_ERR_NEW_OK)
|
||||
if (new_err != TOX_ERR_NEW_OK) {
|
||||
queue_init_message("tox_new returned non-fatal error %d", new_err);
|
||||
}
|
||||
|
||||
init_tox_callbacks(m);
|
||||
load_friendlist(m);
|
||||
load_blocklist(BLOCK_FILE);
|
||||
|
||||
if (tox_self_get_name_size(m) == 0)
|
||||
if (tox_self_get_name_size(m) == 0) {
|
||||
tox_self_set_name(m, (uint8_t *) "Toxic User", strlen("Toxic User"), NULL);
|
||||
}
|
||||
|
||||
tox_options_free(tox_opts);
|
||||
return m;
|
||||
@ -854,8 +876,9 @@ void *thread_cqueue(void *data)
|
||||
ToxWindow *toxwin = get_window_ptr(i);
|
||||
|
||||
if (toxwin != NULL && toxwin->is_chat
|
||||
&& get_friend_connection_status(toxwin->num) != TOX_CONNECTION_NONE)
|
||||
&& get_friend_connection_status(toxwin->num) != TOX_CONNECTION_NONE) {
|
||||
cqueue_try_send(toxwin, m);
|
||||
}
|
||||
}
|
||||
|
||||
pthread_mutex_unlock(&Winthread.lock);
|
||||
@ -956,8 +979,9 @@ static void parse_args(int argc, char *argv[])
|
||||
case 'c':
|
||||
snprintf(arg_opts.config_path, sizeof(arg_opts.config_path), "%s", optarg);
|
||||
|
||||
if (!file_exists(arg_opts.config_path))
|
||||
if (!file_exists(arg_opts.config_path)) {
|
||||
queue_init_message("Config file not found");
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
@ -973,22 +997,26 @@ static void parse_args(int argc, char *argv[])
|
||||
case 'f':
|
||||
arg_opts.use_custom_data = 1;
|
||||
|
||||
if (DATA_FILE)
|
||||
if (DATA_FILE) {
|
||||
free(DATA_FILE);
|
||||
}
|
||||
|
||||
if (BLOCK_FILE)
|
||||
if (BLOCK_FILE) {
|
||||
free(BLOCK_FILE);
|
||||
}
|
||||
|
||||
DATA_FILE = malloc(strlen(optarg) + 1);
|
||||
strcpy(DATA_FILE, optarg);
|
||||
|
||||
if (DATA_FILE == NULL)
|
||||
if (DATA_FILE == NULL) {
|
||||
exit_toxic_err("failed in parse_args", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
BLOCK_FILE = malloc(strlen(optarg) + strlen("-blocklist") + 1);
|
||||
|
||||
if (BLOCK_FILE == NULL)
|
||||
if (BLOCK_FILE == NULL) {
|
||||
exit_toxic_err("failed in parse_args", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
strcpy(BLOCK_FILE, optarg);
|
||||
strcat(BLOCK_FILE, "-blocklist");
|
||||
@ -1010,13 +1038,15 @@ static void parse_args(int argc, char *argv[])
|
||||
arg_opts.proxy_type = TOX_PROXY_TYPE_SOCKS5;
|
||||
snprintf(arg_opts.proxy_address, sizeof(arg_opts.proxy_address), "%s", optarg);
|
||||
|
||||
if (++optind > argc || argv[optind - 1][0] == '-')
|
||||
if (++optind > argc || argv[optind - 1][0] == '-') {
|
||||
exit_toxic_err("Proxy error", FATALERR_PROXY);
|
||||
}
|
||||
|
||||
port = strtol(argv[optind - 1], NULL, 10);
|
||||
|
||||
if (port <= 0 || port > MAX_PORT_RANGE)
|
||||
if (port <= 0 || port > MAX_PORT_RANGE) {
|
||||
exit_toxic_err("Proxy error", FATALERR_PROXY);
|
||||
}
|
||||
|
||||
arg_opts.proxy_port = port;
|
||||
break;
|
||||
@ -1025,13 +1055,15 @@ static void parse_args(int argc, char *argv[])
|
||||
arg_opts.proxy_type = TOX_PROXY_TYPE_HTTP;
|
||||
snprintf(arg_opts.proxy_address, sizeof(arg_opts.proxy_address), "%s", optarg);
|
||||
|
||||
if (++optind > argc || argv[optind - 1][0] == '-')
|
||||
if (++optind > argc || argv[optind - 1][0] == '-') {
|
||||
exit_toxic_err("Proxy error", FATALERR_PROXY);
|
||||
}
|
||||
|
||||
port = strtol(argv[optind - 1], NULL, 10);
|
||||
|
||||
if (port <= 0 || port > MAX_PORT_RANGE)
|
||||
if (port <= 0 || port > MAX_PORT_RANGE) {
|
||||
exit_toxic_err("Proxy error", FATALERR_PROXY);
|
||||
}
|
||||
|
||||
arg_opts.proxy_port = port;
|
||||
break;
|
||||
@ -1039,8 +1071,9 @@ static void parse_args(int argc, char *argv[])
|
||||
case 'r':
|
||||
snprintf(arg_opts.nameserver_path, sizeof(arg_opts.nameserver_path), "%s", optarg);
|
||||
|
||||
if (!file_exists(arg_opts.nameserver_path))
|
||||
if (!file_exists(arg_opts.nameserver_path)) {
|
||||
queue_init_message("nameserver list not found");
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
@ -1051,8 +1084,9 @@ static void parse_args(int argc, char *argv[])
|
||||
case 'T':
|
||||
port = strtol(optarg, NULL, 10);
|
||||
|
||||
if (port <= 0 || port > MAX_PORT_RANGE)
|
||||
if (port <= 0 || port > MAX_PORT_RANGE) {
|
||||
port = 14191;
|
||||
}
|
||||
|
||||
arg_opts.tcp_port = port;
|
||||
break;
|
||||
@ -1085,28 +1119,34 @@ static int rename_old_profile(const char *user_config_dir)
|
||||
char old_data_file[strlen(user_config_dir) + strlen(CONFIGDIR) + strlen(OLD_DATA_NAME) + 1];
|
||||
snprintf(old_data_file, sizeof(old_data_file), "%s%s%s", user_config_dir, CONFIGDIR, OLD_DATA_NAME);
|
||||
|
||||
if (!file_exists(old_data_file))
|
||||
if (!file_exists(old_data_file)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (file_exists(DATA_FILE))
|
||||
if (file_exists(DATA_FILE)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (rename(old_data_file, DATA_FILE) != 0)
|
||||
if (rename(old_data_file, DATA_FILE) != 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
queue_init_message("Data file has been moved to %s", DATA_FILE);
|
||||
|
||||
char old_data_blocklist[strlen(user_config_dir) + strlen(CONFIGDIR) + strlen(OLD_DATA_BLOCKLIST_NAME) + 1];
|
||||
snprintf(old_data_blocklist, sizeof(old_data_blocklist), "%s%s%s", user_config_dir, CONFIGDIR, OLD_DATA_BLOCKLIST_NAME);
|
||||
|
||||
if (!file_exists(old_data_blocklist))
|
||||
if (!file_exists(old_data_blocklist)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (file_exists(BLOCK_FILE))
|
||||
if (file_exists(BLOCK_FILE)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (rename(old_data_blocklist, BLOCK_FILE) != 0)
|
||||
if (rename(old_data_blocklist, BLOCK_FILE) != 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1117,13 +1157,15 @@ static int rename_old_profile(const char *user_config_dir)
|
||||
*/
|
||||
static void init_default_data_files(void)
|
||||
{
|
||||
if (arg_opts.use_custom_data)
|
||||
if (arg_opts.use_custom_data) {
|
||||
return;
|
||||
}
|
||||
|
||||
char *user_config_dir = get_user_config_dir();
|
||||
|
||||
if (user_config_dir == NULL)
|
||||
if (user_config_dir == NULL) {
|
||||
exit_toxic_err("failed in init_default_data_files()", FATALERR_FILEOP);
|
||||
}
|
||||
|
||||
int config_err = create_user_config_dirs(user_config_dir);
|
||||
|
||||
@ -1131,14 +1173,16 @@ static void init_default_data_files(void)
|
||||
DATA_FILE = strdup(DATANAME);
|
||||
BLOCK_FILE = strdup(BLOCKNAME);
|
||||
|
||||
if (DATA_FILE == NULL || BLOCK_FILE == NULL)
|
||||
if (DATA_FILE == NULL || BLOCK_FILE == NULL) {
|
||||
exit_toxic_err("failed in init_default_data_files()", FATALERR_MEMORY);
|
||||
}
|
||||
} else {
|
||||
DATA_FILE = malloc(strlen(user_config_dir) + strlen(CONFIGDIR) + strlen(DATANAME) + 1);
|
||||
BLOCK_FILE = malloc(strlen(user_config_dir) + strlen(CONFIGDIR) + strlen(BLOCKNAME) + 1);
|
||||
|
||||
if (DATA_FILE == NULL || BLOCK_FILE == NULL)
|
||||
if (DATA_FILE == NULL || BLOCK_FILE == NULL) {
|
||||
exit_toxic_err("failed in init_default_data_files()", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
strcpy(DATA_FILE, user_config_dir);
|
||||
strcat(DATA_FILE, CONFIGDIR);
|
||||
@ -1150,8 +1194,9 @@ static void init_default_data_files(void)
|
||||
}
|
||||
|
||||
/* For backwards compatibility with old toxic profile names. TODO: remove this some day */
|
||||
if (rename_old_profile(user_config_dir) == -1)
|
||||
if (rename_old_profile(user_config_dir) == -1) {
|
||||
queue_init_message("Warning: Profile backwards compatibility failed.");
|
||||
}
|
||||
|
||||
free(user_config_dir);
|
||||
}
|
||||
@ -1174,8 +1219,9 @@ int main(int argc, char **argv)
|
||||
parse_args(argc, argv);
|
||||
|
||||
/* Use the -b flag to enable stderr */
|
||||
if (!arg_opts.debug)
|
||||
if (!arg_opts.debug) {
|
||||
freopen("/dev/null", "w", stderr);
|
||||
}
|
||||
|
||||
if (arg_opts.encrypt_data && arg_opts.unencrypt_data) {
|
||||
arg_opts.encrypt_data = 0;
|
||||
@ -1190,17 +1236,19 @@ int main(int argc, char **argv)
|
||||
|
||||
bool datafile_exists = file_exists(DATA_FILE);
|
||||
|
||||
if (!datafile_exists && !arg_opts.unencrypt_data)
|
||||
if (!datafile_exists && !arg_opts.unencrypt_data) {
|
||||
first_time_encrypt("Creating new data file. Would you like to encrypt it? Y/n (q to quit)");
|
||||
else if (arg_opts.encrypt_data)
|
||||
} else if (arg_opts.encrypt_data) {
|
||||
first_time_encrypt("Encrypt existing data file? Y/n (q to quit)");
|
||||
}
|
||||
|
||||
|
||||
/* init user_settings struct and load settings from conf file */
|
||||
user_settings = calloc(1, sizeof(struct user_settings));
|
||||
|
||||
if (user_settings == NULL)
|
||||
if (user_settings == NULL) {
|
||||
exit_toxic_err("failed in main", FATALERR_MEMORY);
|
||||
}
|
||||
|
||||
const char *p = arg_opts.config_path[0] ? arg_opts.config_path : NULL;
|
||||
|
||||
@ -1221,15 +1269,17 @@ int main(int argc, char **argv)
|
||||
|
||||
#ifdef X11
|
||||
|
||||
if (init_xtra(DnD_callback) == -1)
|
||||
if (init_xtra(DnD_callback) == -1) {
|
||||
queue_init_message("X failed to initialize");
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
Tox *m = load_toxic(DATA_FILE);
|
||||
|
||||
if (arg_opts.encrypt_data && !datafile_exists)
|
||||
if (arg_opts.encrypt_data && !datafile_exists) {
|
||||
arg_opts.encrypt_data = 0;
|
||||
}
|
||||
|
||||
|
||||
init_term();
|
||||
@ -1239,15 +1289,18 @@ int main(int argc, char **argv)
|
||||
load_groups(prompt, m);
|
||||
|
||||
/* thread for ncurses stuff */
|
||||
if (pthread_mutex_init(&Winthread.lock, NULL) != 0)
|
||||
if (pthread_mutex_init(&Winthread.lock, NULL) != 0) {
|
||||
exit_toxic_err("failed in main", FATALERR_MUTEX_INIT);
|
||||
}
|
||||
|
||||
if (pthread_create(&Winthread.tid, NULL, thread_winref, (void *) m) != 0)
|
||||
if (pthread_create(&Winthread.tid, NULL, thread_winref, (void *) m) != 0) {
|
||||
exit_toxic_err("failed in main", FATALERR_THREAD_CREATE);
|
||||
}
|
||||
|
||||
/* thread for message queue */
|
||||
if (pthread_create(&cqueue_thread.tid, NULL, thread_cqueue, (void *) m) != 0)
|
||||
if (pthread_create(&cqueue_thread.tid, NULL, thread_cqueue, (void *) m) != 0) {
|
||||
exit_toxic_err("failed in main", FATALERR_THREAD_CREATE);
|
||||
}
|
||||
|
||||
#ifdef AUDIO
|
||||
|
||||
@ -1259,16 +1312,18 @@ int main(int argc, char **argv)
|
||||
#endif /* VIDEO */
|
||||
|
||||
/* AV thread */
|
||||
if (pthread_create(&av_thread.tid, NULL, thread_av, (void *) av) != 0)
|
||||
if (pthread_create(&av_thread.tid, NULL, thread_av, (void *) av) != 0) {
|
||||
exit_toxic_err("failed in main", FATALERR_THREAD_CREATE);
|
||||
}
|
||||
|
||||
set_primary_device(input, user_settings->audio_in_dev);
|
||||
set_primary_device(output, user_settings->audio_out_dev);
|
||||
|
||||
#elif SOUND_NOTIFY
|
||||
|
||||
if ( init_devices() == de_InternalError )
|
||||
if (init_devices() == de_InternalError) {
|
||||
queue_init_message("Failed to init audio devices");
|
||||
}
|
||||
|
||||
#endif /* AUDIO */
|
||||
|
||||
@ -1282,8 +1337,9 @@ int main(int argc, char **argv)
|
||||
init_notify(60, 3000);
|
||||
|
||||
/* screen/tmux auto-away timer */
|
||||
if (init_mplex_away_timer(m) == -1)
|
||||
if (init_mplex_away_timer(m) == -1) {
|
||||
queue_init_message("Failed to init mplex auto-away.");
|
||||
}
|
||||
|
||||
int nodeslist_ret = load_DHT_nodeslist();
|
||||
|
||||
@ -1312,8 +1368,9 @@ int main(int argc, char **argv)
|
||||
if (timed_out(last_save, AUTOSAVE_FREQ)) {
|
||||
pthread_mutex_lock(&Winthread.lock);
|
||||
|
||||
if (store_data(m, DATA_FILE) != 0)
|
||||
if (store_data(m, DATA_FILE) != 0) {
|
||||
line_info_add(prompt, NULL, NULL, NULL, SYS_MSG, 0, RED, "WARNING: Failed to save to data file");
|
||||
}
|
||||
|
||||
pthread_mutex_unlock(&Winthread.lock);
|
||||
|
||||
|
@ -96,8 +96,8 @@ typedef enum _FATAL_ERRS {
|
||||
Uncomment if necessary */
|
||||
/* #define URXVT_FIX */
|
||||
|
||||
void lock_status ();
|
||||
void unlock_status ();
|
||||
void lock_status();
|
||||
void unlock_status();
|
||||
|
||||
void exit_toxic_success(Tox *m);
|
||||
void exit_toxic_err(const char *errmsg, int errcode);
|
||||
@ -127,7 +127,7 @@ void on_file_chunk_request(Tox *m, uint32_t friendnumber, uint32_t filenumber, u
|
||||
void *userdata);
|
||||
void on_file_recv_chunk(Tox *m, uint32_t friendnumber, uint32_t filenumber, uint64_t position, const uint8_t *data,
|
||||
size_t length, void *userdata);
|
||||
void on_file_control (Tox *m, uint32_t friendnumber, uint32_t filenumber, TOX_FILE_CONTROL control, void *userdata);
|
||||
void on_file_control(Tox *m, uint32_t friendnumber, uint32_t filenumber, TOX_FILE_CONTROL control, void *userdata);
|
||||
void on_file_recv(Tox *m, uint32_t friendnumber, uint32_t filenumber, uint32_t kind, uint64_t file_size,
|
||||
const uint8_t *filename, size_t filename_length, void *userdata);
|
||||
void on_typing_change(Tox *m, uint32_t friendnumber, bool is_typing, void *userdata);
|
||||
|
@ -33,8 +33,9 @@
|
||||
/* Adds char to line at pos. Return 0 on success, -1 if line buffer is full */
|
||||
int add_char_to_buf(ChatContext *ctx, wint_t ch)
|
||||
{
|
||||
if (ctx->len >= MAX_STR_SIZE - 1)
|
||||
if (ctx->len >= MAX_STR_SIZE - 1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
wmemmove(&ctx->line[ctx->pos + 1], &ctx->line[ctx->pos], ctx->len - ctx->pos);
|
||||
ctx->line[ctx->pos++] = ch;
|
||||
@ -46,8 +47,9 @@ int add_char_to_buf(ChatContext *ctx, wint_t ch)
|
||||
/* Deletes the character before pos. Return 0 on success, -1 if nothing to delete */
|
||||
int del_char_buf_bck(ChatContext *ctx)
|
||||
{
|
||||
if (ctx->pos <= 0)
|
||||
if (ctx->pos <= 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
wmemmove(&ctx->line[ctx->pos - 1], &ctx->line[ctx->pos], ctx->len - ctx->pos);
|
||||
--ctx->pos;
|
||||
@ -59,8 +61,9 @@ int del_char_buf_bck(ChatContext *ctx)
|
||||
/* Deletes the character at pos. Return 0 on success, -1 if nothing to delete. */
|
||||
int del_char_buf_frnt(ChatContext *ctx)
|
||||
{
|
||||
if (ctx->pos >= ctx->len)
|
||||
if (ctx->pos >= ctx->len) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
wmemmove(&ctx->line[ctx->pos], &ctx->line[ctx->pos + 1], ctx->len - ctx->pos - 1);
|
||||
ctx->line[--ctx->len] = L'\0';
|
||||
@ -72,8 +75,9 @@ int del_char_buf_frnt(ChatContext *ctx)
|
||||
Return 0 on success, -1 if noting to discard. */
|
||||
int discard_buf(ChatContext *ctx)
|
||||
{
|
||||
if (ctx->pos <= 0)
|
||||
if (ctx->pos <= 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
ctx->yank_len = ctx->pos;
|
||||
wmemcpy(ctx->yank, ctx->line, ctx->yank_len);
|
||||
@ -92,8 +96,9 @@ int discard_buf(ChatContext *ctx)
|
||||
Return 0 on success, -1 if nothing to kill. */
|
||||
int kill_buf(ChatContext *ctx)
|
||||
{
|
||||
if (ctx->len <= ctx->pos)
|
||||
if (ctx->len <= ctx->pos) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
ctx->yank_len = ctx->len - ctx->pos;
|
||||
wmemcpy(ctx->yank, &ctx->line[ctx->pos], ctx->yank_len);
|
||||
@ -109,11 +114,13 @@ int kill_buf(ChatContext *ctx)
|
||||
Return 0 on success, -1 if yank buffer is empty or too long */
|
||||
int yank_buf(ChatContext *ctx)
|
||||
{
|
||||
if (!ctx->yank[0])
|
||||
if (!ctx->yank[0]) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (ctx->yank_len + ctx->len >= MAX_STR_SIZE)
|
||||
if (ctx->yank_len + ctx->len >= MAX_STR_SIZE) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
wmemmove(&ctx->line[ctx->pos + ctx->yank_len], &ctx->line[ctx->pos], ctx->len - ctx->pos);
|
||||
wmemcpy(&ctx->line[ctx->pos], ctx->yank, ctx->yank_len);
|
||||
@ -130,8 +137,9 @@ int yank_buf(ChatContext *ctx)
|
||||
Return 0 on success, -1 if nothing to delete */
|
||||
int del_word_buf(ChatContext *ctx)
|
||||
{
|
||||
if (ctx->len == 0 || ctx->pos == 0)
|
||||
if (ctx->len == 0 || ctx->pos == 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
int i = ctx->pos, count = 0;
|
||||
|
||||
@ -169,17 +177,20 @@ void reset_buf(ChatContext *ctx)
|
||||
/* Removes trailing spaces and newlines from line. */
|
||||
void rm_trailing_spaces_buf(ChatContext *ctx)
|
||||
{
|
||||
if (ctx->len <= 0)
|
||||
if (ctx->len <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (ctx->line[ctx->len - 1] != ' ' && ctx->line[ctx->len - 1] != L'¶')
|
||||
if (ctx->line[ctx->len - 1] != ' ' && ctx->line[ctx->len - 1] != L'¶') {
|
||||
return;
|
||||
}
|
||||
|
||||
int i;
|
||||
|
||||
for (i = ctx->len - 1; i >= 0; --i) {
|
||||
if (ctx->line[i] != ' ' && ctx->line[i] != L'¶')
|
||||
if (ctx->line[i] != ' ' && ctx->line[i] != L'¶') {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
ctx->len = i + 1;
|
||||
@ -195,8 +206,9 @@ static void shift_hist_back(ChatContext *ctx)
|
||||
int i;
|
||||
int n = MAX_LINE_HIST - HIST_PURGE;
|
||||
|
||||
for (i = 0; i < n; ++i)
|
||||
for (i = 0; i < n; ++i) {
|
||||
wmemcpy(ctx->ln_history[i], ctx->ln_history[i + HIST_PURGE], MAX_STR_SIZE);
|
||||
}
|
||||
|
||||
ctx->hst_tot = n;
|
||||
}
|
||||
@ -204,11 +216,13 @@ static void shift_hist_back(ChatContext *ctx)
|
||||
/* adds a line to the ln_history buffer at hst_pos and sets hst_pos to end of history. */
|
||||
void add_line_to_hist(ChatContext *ctx)
|
||||
{
|
||||
if (ctx->len >= MAX_STR_SIZE)
|
||||
if (ctx->len >= MAX_STR_SIZE) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (ctx->hst_tot >= MAX_LINE_HIST)
|
||||
if (ctx->hst_tot >= MAX_LINE_HIST) {
|
||||
shift_hist_back(ctx);
|
||||
}
|
||||
|
||||
++ctx->hst_tot;
|
||||
ctx->hst_pos = ctx->hst_tot;
|
||||
@ -248,8 +262,9 @@ void strsubst(char *str, char old, char new)
|
||||
int i;
|
||||
|
||||
for (i = 0; str[i] != '\0'; ++i)
|
||||
if (str[i] == old)
|
||||
if (str[i] == old) {
|
||||
str[i] = new;
|
||||
}
|
||||
}
|
||||
|
||||
void wstrsubst(wchar_t *str, wchar_t old, wchar_t new)
|
||||
@ -257,6 +272,7 @@ void wstrsubst(wchar_t *str, wchar_t old, wchar_t new)
|
||||
int i;
|
||||
|
||||
for (i = 0; str[i] != L'\0'; ++i)
|
||||
if (str[i] == old)
|
||||
if (str[i] == old) {
|
||||
str[i] = new;
|
||||
}
|
||||
}
|
||||
|
136
src/video_call.c
136
src/video_call.c
@ -41,15 +41,15 @@
|
||||
|
||||
#define default_video_bit_rate 5000
|
||||
|
||||
void receive_video_frame_cb( ToxAV *av, uint32_t friend_number,
|
||||
uint16_t width, uint16_t height,
|
||||
uint8_t const *y, uint8_t const *u, uint8_t const *v,
|
||||
int32_t ystride, int32_t ustride, int32_t vstride,
|
||||
void *user_data );
|
||||
void receive_video_frame_cb(ToxAV *av, uint32_t friend_number,
|
||||
uint16_t width, uint16_t height,
|
||||
uint8_t const *y, uint8_t const *u, uint8_t const *v,
|
||||
int32_t ystride, int32_t ustride, int32_t vstride,
|
||||
void *user_data);
|
||||
|
||||
void video_bit_rate_status_cb( ToxAV *av, uint32_t friend_number, uint32_t video_bit_rate, void *user_data);
|
||||
void video_bit_rate_status_cb(ToxAV *av, uint32_t friend_number, uint32_t video_bit_rate, void *user_data);
|
||||
|
||||
static void print_err (ToxWindow *self, const char *error_str)
|
||||
static void print_err(ToxWindow *self, const char *error_str)
|
||||
{
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%s", error_str);
|
||||
}
|
||||
@ -62,13 +62,13 @@ ToxAV *init_video(ToxWindow *self, Tox *tox)
|
||||
CallControl.video_bit_rate = 0;
|
||||
CallControl.video_frame_duration = 10;
|
||||
|
||||
if ( !CallControl.av ) {
|
||||
if (!CallControl.av) {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Video failed to init with ToxAV instance");
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if ( init_video_devices(CallControl.av) == vde_InternalError ) {
|
||||
if (init_video_devices(CallControl.av) == vde_InternalError) {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to init video devices");
|
||||
|
||||
return NULL;
|
||||
@ -89,8 +89,9 @@ void terminate_video()
|
||||
|
||||
stop_video_transmission(this_call, i);
|
||||
|
||||
if ( this_call->vout_idx != -1 )
|
||||
if (this_call->vout_idx != -1) {
|
||||
close_video_device(vdt_output, this_call->vout_idx);
|
||||
}
|
||||
}
|
||||
|
||||
terminate_video_devices();
|
||||
@ -104,18 +105,19 @@ void read_video_device_callback(int16_t width, int16_t height, const uint8_t *y,
|
||||
TOXAV_ERR_SEND_FRAME error;
|
||||
|
||||
/* Drop frame if video sending is disabled */
|
||||
if ( CallControl.video_bit_rate == 0 || this_call->vin_idx == -1 ) {
|
||||
if (CallControl.video_bit_rate == 0 || this_call->vin_idx == -1) {
|
||||
line_info_add(CallControl.prompt, NULL, NULL, NULL, SYS_MSG, 0, 0, "Video frame dropped.");
|
||||
return;
|
||||
}
|
||||
|
||||
if ( toxav_video_send_frame(CallControl.av, friend_number, width, height, y, u, v, &error ) == false ) {
|
||||
if (toxav_video_send_frame(CallControl.av, friend_number, width, height, y, u, v, &error) == false) {
|
||||
line_info_add(CallControl.prompt, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to send video frame");
|
||||
|
||||
if ( error == TOXAV_ERR_SEND_FRAME_NULL )
|
||||
if (error == TOXAV_ERR_SEND_FRAME_NULL) {
|
||||
line_info_add(CallControl.prompt, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to capture video frame");
|
||||
else if ( error == TOXAV_ERR_SEND_FRAME_INVALID )
|
||||
} else if (error == TOXAV_ERR_SEND_FRAME_INVALID) {
|
||||
line_info_add(CallControl.prompt, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to prepare video frame");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -129,24 +131,24 @@ void write_video_device_callback(uint32_t friend_number, uint16_t width, uint16_
|
||||
|
||||
int start_video_transmission(ToxWindow *self, ToxAV *av, Call *call)
|
||||
{
|
||||
if ( !self || !av) {
|
||||
if (!self || !av) {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to prepare transmission");
|
||||
return -1;
|
||||
}
|
||||
|
||||
CallControl.video_bit_rate = default_video_bit_rate;
|
||||
|
||||
if ( toxav_video_set_bit_rate(CallControl.av, self->num, CallControl.video_bit_rate, NULL) == false ) {
|
||||
if (toxav_video_set_bit_rate(CallControl.av, self->num, CallControl.video_bit_rate, NULL) == false) {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to set video bit rate");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if ( open_primary_video_device(vdt_input, &call->vin_idx) != vde_None ) {
|
||||
if (open_primary_video_device(vdt_input, &call->vin_idx) != vde_None) {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to open input video device!");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if ( register_video_device_callback(self->num, call->vin_idx, read_video_device_callback, &self->num) != vde_None ) {
|
||||
if (register_video_device_callback(self->num, call->vin_idx, read_video_device_callback, &self->num) != vde_None) {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to register input video handler!");
|
||||
return -1;
|
||||
}
|
||||
@ -159,7 +161,7 @@ int stop_video_transmission(Call *call, int friend_number)
|
||||
CallControl.video_bit_rate = 0;
|
||||
toxav_video_set_bit_rate(CallControl.av, friend_number, CallControl.video_bit_rate, NULL);
|
||||
|
||||
if ( call->vin_idx != -1 ) {
|
||||
if (call->vin_idx != -1) {
|
||||
close_video_device(vdt_input, call->vin_idx);
|
||||
call->vin_idx = -1;
|
||||
}
|
||||
@ -196,8 +198,9 @@ void callback_recv_video_starting(uint32_t friend_number)
|
||||
{
|
||||
Call *this_call = &CallControl.calls[friend_number];
|
||||
|
||||
if ( this_call->vout_idx != -1 )
|
||||
if (this_call->vout_idx != -1) {
|
||||
return;
|
||||
}
|
||||
|
||||
open_primary_video_device(vdt_output, &this_call->vout_idx);
|
||||
}
|
||||
@ -220,8 +223,8 @@ void callback_video_starting(uint32_t friend_number)
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
|
||||
if ( windows[i].is_call && windows[i].num == friend_number ) {
|
||||
if ( 0 != start_video_transmission(&windows[i], CallControl.av, this_call) ) {
|
||||
if (windows[i].is_call && windows[i].num == friend_number) {
|
||||
if (0 != start_video_transmission(&windows[i], CallControl.av, this_call)) {
|
||||
line_info_add(&windows[i], NULL, NULL, NULL, SYS_MSG, 0, 0, "Error starting transmission!");
|
||||
return;
|
||||
}
|
||||
@ -249,54 +252,60 @@ void cmd_video(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[M
|
||||
const char *error_str;
|
||||
Call *this_call = &CallControl.calls[self->num];
|
||||
|
||||
if ( argc != 0 ) {
|
||||
if (argc != 0) {
|
||||
error_str = "Unknown arguments.";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if ( !CallControl.av ) {
|
||||
if (!CallControl.av) {
|
||||
error_str = "ToxAV not supported!";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if ( !self->stb->connection ) {
|
||||
if (!self->stb->connection) {
|
||||
error_str = "Friend is offline.";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if ( !self->is_call ) {
|
||||
if (!self->is_call) {
|
||||
error_str = "Not in call!";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if ( this_call->vin_idx == -1 )
|
||||
if (this_call->vin_idx == -1) {
|
||||
callback_video_starting(self->num);
|
||||
else
|
||||
} else {
|
||||
callback_video_end(self->num);
|
||||
}
|
||||
|
||||
return;
|
||||
on_error:
|
||||
print_err (self, error_str);
|
||||
print_err(self, error_str);
|
||||
}
|
||||
|
||||
void cmd_list_video_devices(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
|
||||
{
|
||||
const char *error_str;
|
||||
|
||||
if ( argc != 1 ) {
|
||||
if ( argc < 1 ) error_str = "Type must be specified!";
|
||||
else error_str = "Only one argument allowed!";
|
||||
if (argc != 1) {
|
||||
if (argc < 1) {
|
||||
error_str = "Type must be specified!";
|
||||
} else {
|
||||
error_str = "Only one argument allowed!";
|
||||
}
|
||||
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
VideoDeviceType type;
|
||||
|
||||
if ( strcasecmp(argv[1], "in") == 0 ) /* Input devices */
|
||||
if (strcasecmp(argv[1], "in") == 0) { /* Input devices */
|
||||
type = vdt_input;
|
||||
}
|
||||
|
||||
else if ( strcasecmp(argv[1], "out") == 0 ) /* Output devices */
|
||||
else if (strcasecmp(argv[1], "out") == 0) { /* Output devices */
|
||||
type = vdt_output;
|
||||
}
|
||||
|
||||
else {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid type: %s", argv[1]);
|
||||
@ -307,7 +316,7 @@ void cmd_list_video_devices(WINDOW *window, ToxWindow *self, Tox *m, int argc, c
|
||||
|
||||
return;
|
||||
on_error:
|
||||
print_err (self, error_str);
|
||||
print_err(self, error_str);
|
||||
}
|
||||
|
||||
/* This changes primary video device only */
|
||||
@ -315,21 +324,27 @@ void cmd_change_video_device(WINDOW *window, ToxWindow *self, Tox *m, int argc,
|
||||
{
|
||||
const char *error_str;
|
||||
|
||||
if ( argc != 2 ) {
|
||||
if ( argc < 1 ) error_str = "Type must be specified!";
|
||||
else if ( argc < 2 ) error_str = "Must have id!";
|
||||
else error_str = "Only two arguments allowed!";
|
||||
if (argc != 2) {
|
||||
if (argc < 1) {
|
||||
error_str = "Type must be specified!";
|
||||
} else if (argc < 2) {
|
||||
error_str = "Must have id!";
|
||||
} else {
|
||||
error_str = "Only two arguments allowed!";
|
||||
}
|
||||
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
VideoDeviceType type;
|
||||
|
||||
if ( strcmp(argv[1], "in") == 0 ) /* Input devices */
|
||||
if (strcmp(argv[1], "in") == 0) { /* Input devices */
|
||||
type = vdt_input;
|
||||
}
|
||||
|
||||
else if ( strcmp(argv[1], "out") == 0 ) /* Output devices */
|
||||
else if (strcmp(argv[1], "out") == 0) { /* Output devices */
|
||||
type = vdt_output;
|
||||
}
|
||||
|
||||
else {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid type: %s", argv[1]);
|
||||
@ -340,40 +355,46 @@ void cmd_change_video_device(WINDOW *window, ToxWindow *self, Tox *m, int argc,
|
||||
char *end;
|
||||
long int selection = strtol(argv[2], &end, 10);
|
||||
|
||||
if ( *end ) {
|
||||
if (*end) {
|
||||
error_str = "Invalid input";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if ( set_primary_video_device(type, selection) == vde_InvalidSelection ) {
|
||||
if (set_primary_video_device(type, selection) == vde_InvalidSelection) {
|
||||
error_str = "Invalid selection!";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
return;
|
||||
on_error:
|
||||
print_err (self, error_str);
|
||||
print_err(self, error_str);
|
||||
}
|
||||
|
||||
void cmd_ccur_video_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
|
||||
{
|
||||
const char *error_str;
|
||||
|
||||
if ( argc != 2 ) {
|
||||
if ( argc < 1 ) error_str = "Type must be specified!";
|
||||
else if ( argc < 2 ) error_str = "Must have id!";
|
||||
else error_str = "Only two arguments allowed!";
|
||||
if (argc != 2) {
|
||||
if (argc < 1) {
|
||||
error_str = "Type must be specified!";
|
||||
} else if (argc < 2) {
|
||||
error_str = "Must have id!";
|
||||
} else {
|
||||
error_str = "Only two arguments allowed!";
|
||||
}
|
||||
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
VideoDeviceType type;
|
||||
|
||||
if ( strcmp(argv[1], "in") == 0 ) /* Input devices */
|
||||
if (strcmp(argv[1], "in") == 0) { /* Input devices */
|
||||
type = vdt_input;
|
||||
}
|
||||
|
||||
else if ( strcmp(argv[1], "out") == 0 ) /* Output devices */
|
||||
else if (strcmp(argv[1], "out") == 0) { /* Output devices */
|
||||
type = vdt_output;
|
||||
}
|
||||
|
||||
else {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid type: %s", argv[1]);
|
||||
@ -384,23 +405,23 @@ void cmd_ccur_video_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, ch
|
||||
char *end;
|
||||
long int selection = strtol(argv[2], &end, 10);
|
||||
|
||||
if ( *end ) {
|
||||
if (*end) {
|
||||
error_str = "Invalid input";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
if ( video_selection_valid(type, selection) == vde_InvalidSelection ) {
|
||||
if (video_selection_valid(type, selection) == vde_InvalidSelection) {
|
||||
error_str = "Invalid selection!";
|
||||
goto on_error;
|
||||
}
|
||||
|
||||
/* If call is active, change device */
|
||||
if ( self->is_call ) {
|
||||
if (self->is_call) {
|
||||
Call *this_call = &CallControl.calls[self->num];
|
||||
|
||||
if ( this_call->ttas ) {
|
||||
if (this_call->ttas) {
|
||||
|
||||
if ( type == vdt_output ) {
|
||||
if (type == vdt_output) {
|
||||
} else {
|
||||
/* TODO: check for failure */
|
||||
close_video_device(vdt_input, this_call->vin_idx);
|
||||
@ -414,15 +435,16 @@ void cmd_ccur_video_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, ch
|
||||
|
||||
return;
|
||||
on_error:
|
||||
print_err (self, error_str);
|
||||
print_err(self, error_str);
|
||||
}
|
||||
|
||||
void stop_video_stream(ToxWindow *self)
|
||||
{
|
||||
Call *this_call = &CallControl.calls[self->num];
|
||||
|
||||
if (this_call && this_call->vin_idx != -1)
|
||||
if (this_call && this_call->vin_idx != -1) {
|
||||
stop_video_transmission(this_call, self->num);
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
@ -187,8 +187,9 @@ VideoDeviceError init_video_devices()
|
||||
|
||||
#if defined(__OSX__)
|
||||
|
||||
if ( osx_video_init((char **)video_devices_names[vdt_input], &size[vdt_input]) != 0 )
|
||||
if (osx_video_init((char **)video_devices_names[vdt_input], &size[vdt_input]) != 0) {
|
||||
return vde_InternalError;
|
||||
}
|
||||
|
||||
#else /* not __OSX__*/
|
||||
|
||||
@ -199,14 +200,14 @@ VideoDeviceError init_video_devices()
|
||||
|
||||
fd = open(device_address, O_RDWR | O_NONBLOCK, 0);
|
||||
|
||||
if ( fd == -1 ) {
|
||||
if (fd == -1) {
|
||||
break;
|
||||
} else {
|
||||
struct v4l2_capability cap;
|
||||
char *video_input_name;
|
||||
|
||||
/* Query V4L for capture capabilities */
|
||||
if ( -1 != ioctl(fd, VIDIOC_QUERYCAP, &cap) ) {
|
||||
if (-1 != ioctl(fd, VIDIOC_QUERYCAP, &cap)) {
|
||||
video_input_name = (char *)malloc(strlen((const char *)cap.card) + strlen(device_address) + 4);
|
||||
strcpy(video_input_name, (char *)cap.card);
|
||||
strcat(video_input_name, " (");
|
||||
@ -232,13 +233,15 @@ VideoDeviceError init_video_devices()
|
||||
video_devices_names[vdt_output][0] = video_output_name;
|
||||
|
||||
// Start poll thread
|
||||
if ( pthread_mutex_init(&video_mutex, NULL) != 0 )
|
||||
if (pthread_mutex_init(&video_mutex, NULL) != 0) {
|
||||
return vde_InternalError;
|
||||
}
|
||||
|
||||
pthread_t thread_id;
|
||||
|
||||
if ( pthread_create(&thread_id, NULL, video_thread_poll, NULL) != 0 || pthread_detach(thread_id) != 0 )
|
||||
if (pthread_create(&thread_id, NULL, video_thread_poll, NULL) != 0 || pthread_detach(thread_id) != 0) {
|
||||
return vde_InternalError;
|
||||
}
|
||||
|
||||
#ifdef VIDEO
|
||||
av = av_;
|
||||
@ -262,8 +265,9 @@ VideoDeviceError terminate_video_devices()
|
||||
free((void *)video_devices_names[vdt_input][i]);
|
||||
}
|
||||
|
||||
if ( pthread_mutex_destroy(&video_mutex) != 0 )
|
||||
if (pthread_mutex_destroy(&video_mutex) != 0) {
|
||||
return (VideoDeviceError) vde_InternalError;
|
||||
}
|
||||
|
||||
#ifdef __OSX__
|
||||
osx_video_release();
|
||||
@ -277,14 +281,16 @@ VideoDeviceError register_video_device_callback(int32_t friend_number, uint32_t
|
||||
{
|
||||
#if defined(__OSX__)
|
||||
|
||||
if ( size[vdt_input] <= device_idx || !video_devices_running[vdt_input][device_idx] )
|
||||
if (size[vdt_input] <= device_idx || !video_devices_running[vdt_input][device_idx]) {
|
||||
return vde_InvalidSelection;
|
||||
}
|
||||
|
||||
#else /* not __OSX__ */
|
||||
|
||||
if ( size[vdt_input] <= device_idx || !video_devices_running[vdt_input][device_idx]
|
||||
|| !video_devices_running[vdt_input][device_idx]->fd )
|
||||
if (size[vdt_input] <= device_idx || !video_devices_running[vdt_input][device_idx]
|
||||
|| !video_devices_running[vdt_input][device_idx]->fd) {
|
||||
return vde_InvalidSelection;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@ -299,7 +305,9 @@ VideoDeviceError register_video_device_callback(int32_t friend_number, uint32_t
|
||||
|
||||
VideoDeviceError set_primary_video_device(VideoDeviceType type, int32_t selection)
|
||||
{
|
||||
if ( size[type] <= selection || selection < 0 ) return vde_InvalidSelection;
|
||||
if (size[type] <= selection || selection < 0) {
|
||||
return vde_InvalidSelection;
|
||||
}
|
||||
|
||||
primary_video_device[type] = selection;
|
||||
|
||||
@ -318,14 +326,16 @@ void get_primary_video_device_name(VideoDeviceType type, char *buf, int size)
|
||||
|
||||
VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint32_t *device_idx)
|
||||
{
|
||||
if ( size[type] <= selection || selection < 0 ) return vde_InvalidSelection;
|
||||
if (size[type] <= selection || selection < 0) {
|
||||
return vde_InvalidSelection;
|
||||
}
|
||||
|
||||
lock;
|
||||
|
||||
uint32_t i, temp_idx = -1;
|
||||
|
||||
for (i = 0; i < MAX_DEVICES; ++i) {
|
||||
if ( !video_devices_running[type][i] ) {
|
||||
if (!video_devices_running[type][i]) {
|
||||
temp_idx = i;
|
||||
break;
|
||||
}
|
||||
@ -337,7 +347,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
|
||||
}
|
||||
|
||||
for (i = 0; i < MAX_DEVICES; i ++) { /* Check if any device has the same selection */
|
||||
if ( video_devices_running[type][i] && video_devices_running[type][i]->selection == selection ) {
|
||||
if (video_devices_running[type][i] && video_devices_running[type][i]->selection == selection) {
|
||||
|
||||
video_devices_running[type][temp_idx] = video_devices_running[type][i];
|
||||
video_devices_running[type][i]->ref_count++;
|
||||
@ -350,18 +360,18 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
|
||||
VideoDevice *device = video_devices_running[type][temp_idx] = calloc(1, sizeof(VideoDevice));
|
||||
device->selection = selection;
|
||||
|
||||
if ( pthread_mutex_init(device->mutex, NULL) != 0 ) {
|
||||
if (pthread_mutex_init(device->mutex, NULL) != 0) {
|
||||
free(device);
|
||||
unlock;
|
||||
return vde_InternalError;
|
||||
}
|
||||
|
||||
if ( type == vdt_input ) {
|
||||
if (type == vdt_input) {
|
||||
video_thread_paused = true;
|
||||
|
||||
#if defined(__OSX__)
|
||||
|
||||
if ( osx_video_open_device(selection, &device->video_width, &device->video_height) != 0 ) {
|
||||
if (osx_video_open_device(selection, &device->video_width, &device->video_height) != 0) {
|
||||
free(device);
|
||||
unlock;
|
||||
return vde_FailedStart;
|
||||
@ -374,7 +384,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
|
||||
|
||||
device->fd = open(device_address, O_RDWR);
|
||||
|
||||
if ( device->fd == -1 ) {
|
||||
if (device->fd == -1) {
|
||||
unlock;
|
||||
return vde_FailedStart;
|
||||
}
|
||||
@ -382,7 +392,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
|
||||
/* Obtain video device capabilities */
|
||||
struct v4l2_capability cap;
|
||||
|
||||
if ( -1 == xioctl(device->fd, VIDIOC_QUERYCAP, &cap) ) {
|
||||
if (-1 == xioctl(device->fd, VIDIOC_QUERYCAP, &cap)) {
|
||||
close(device->fd);
|
||||
free(device);
|
||||
unlock;
|
||||
@ -396,7 +406,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
|
||||
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
||||
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
|
||||
|
||||
if ( -1 == xioctl(device->fd, VIDIOC_S_FMT, &fmt) ) {
|
||||
if (-1 == xioctl(device->fd, VIDIOC_S_FMT, &fmt)) {
|
||||
close(device->fd);
|
||||
free(device);
|
||||
unlock;
|
||||
@ -413,14 +423,14 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
|
||||
req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
||||
req.memory = V4L2_MEMORY_MMAP;
|
||||
|
||||
if ( -1 == xioctl(device->fd, VIDIOC_REQBUFS, &req) ) {
|
||||
if (-1 == xioctl(device->fd, VIDIOC_REQBUFS, &req)) {
|
||||
close(device->fd);
|
||||
free(device);
|
||||
unlock;
|
||||
return vde_FailedStart;
|
||||
}
|
||||
|
||||
if ( req.count < 2 ) {
|
||||
if (req.count < 2) {
|
||||
close(device->fd);
|
||||
free(device);
|
||||
unlock;
|
||||
@ -437,7 +447,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
|
||||
buf.memory = V4L2_MEMORY_MMAP;
|
||||
buf.index = i;
|
||||
|
||||
if ( -1 == xioctl(device->fd, VIDIOC_QUERYBUF, &buf) ) {
|
||||
if (-1 == xioctl(device->fd, VIDIOC_QUERYBUF, &buf)) {
|
||||
close(device->fd);
|
||||
free(device);
|
||||
unlock;
|
||||
@ -451,9 +461,10 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
|
||||
MAP_SHARED /* recommended */,
|
||||
device->fd, buf.m.offset);
|
||||
|
||||
if ( MAP_FAILED == device->buffers[i].start ) {
|
||||
for (i = 0; i < buf.index; ++i)
|
||||
if (MAP_FAILED == device->buffers[i].start) {
|
||||
for (i = 0; i < buf.index; ++i) {
|
||||
munmap(device->buffers[i].start, device->buffers[i].length);
|
||||
}
|
||||
|
||||
close(device->fd);
|
||||
free(device);
|
||||
@ -474,9 +485,10 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
|
||||
buf.memory = V4L2_MEMORY_MMAP;
|
||||
buf.index = i;
|
||||
|
||||
if ( -1 == xioctl(device->fd, VIDIOC_QBUF, &buf) ) {
|
||||
for (i = 0; i < device->n_buffers; ++i)
|
||||
if (-1 == xioctl(device->fd, VIDIOC_QBUF, &buf)) {
|
||||
for (i = 0; i < device->n_buffers; ++i) {
|
||||
munmap(device->buffers[i].start, device->buffers[i].length);
|
||||
}
|
||||
|
||||
close(device->fd);
|
||||
free(device);
|
||||
@ -488,7 +500,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
|
||||
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
||||
|
||||
/* Turn on video stream */
|
||||
if ( -1 == xioctl(device->fd, VIDIOC_STREAMON, &type) ) {
|
||||
if (-1 == xioctl(device->fd, VIDIOC_STREAMON, &type)) {
|
||||
close_video_device(vdt_input, temp_idx);
|
||||
unlock;
|
||||
return vde_FailedStart;
|
||||
@ -497,7 +509,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
|
||||
#endif
|
||||
|
||||
/* Create X11 window associated to device */
|
||||
if ( (device->x_display = XOpenDisplay(NULL)) == NULL ) {
|
||||
if ((device->x_display = XOpenDisplay(NULL)) == NULL) {
|
||||
close_video_device(vdt_input, temp_idx);
|
||||
unlock;
|
||||
return vde_FailedStart;
|
||||
@ -505,9 +517,9 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
|
||||
|
||||
int screen = DefaultScreen(device->x_display);
|
||||
|
||||
if ( !(device->x_window = XCreateSimpleWindow(device->x_display, RootWindow(device->x_display, screen), 0, 0,
|
||||
device->video_width, device->video_height, 0, BlackPixel(device->x_display, screen),
|
||||
BlackPixel(device->x_display, screen))) ) {
|
||||
if (!(device->x_window = XCreateSimpleWindow(device->x_display, RootWindow(device->x_display, screen), 0, 0,
|
||||
device->video_width, device->video_height, 0, BlackPixel(device->x_display, screen),
|
||||
BlackPixel(device->x_display, screen)))) {
|
||||
close_video_device(vdt_input, temp_idx);
|
||||
unlock;
|
||||
return vde_FailedStart;
|
||||
@ -516,7 +528,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
|
||||
XStoreName(device->x_display, device->x_window, "Video Preview");
|
||||
XSelectInput(device->x_display, device->x_window, ExposureMask | ButtonPressMask | KeyPressMask);
|
||||
|
||||
if ( (device->x_gc = DefaultGC(device->x_display, screen)) == NULL ) {
|
||||
if ((device->x_gc = DefaultGC(device->x_display, screen)) == NULL) {
|
||||
close_video_device(vdt_input, temp_idx);
|
||||
unlock;
|
||||
return vde_FailedStart;
|
||||
@ -537,7 +549,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
|
||||
} else { /* vdt_output */
|
||||
|
||||
/* Create X11 window associated to device */
|
||||
if ( (device->x_display = XOpenDisplay(NULL)) == NULL ) {
|
||||
if ((device->x_display = XOpenDisplay(NULL)) == NULL) {
|
||||
close_video_device(vdt_output, temp_idx);
|
||||
unlock;
|
||||
return vde_FailedStart;
|
||||
@ -545,8 +557,8 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
|
||||
|
||||
int screen = DefaultScreen(device->x_display);
|
||||
|
||||
if ( !(device->x_window = XCreateSimpleWindow(device->x_display, RootWindow(device->x_display, screen), 0, 0,
|
||||
100, 100, 0, BlackPixel(device->x_display, screen), BlackPixel(device->x_display, screen))) ) {
|
||||
if (!(device->x_window = XCreateSimpleWindow(device->x_display, RootWindow(device->x_display, screen), 0, 0,
|
||||
100, 100, 0, BlackPixel(device->x_display, screen), BlackPixel(device->x_display, screen)))) {
|
||||
close_video_device(vdt_output, temp_idx);
|
||||
unlock;
|
||||
return vde_FailedStart;
|
||||
@ -555,7 +567,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
|
||||
XStoreName(device->x_display, device->x_window, "Video Receive");
|
||||
XSelectInput(device->x_display, device->x_window, ExposureMask | ButtonPressMask | KeyPressMask);
|
||||
|
||||
if ( (device->x_gc = DefaultGC(device->x_display, screen)) == NULL ) {
|
||||
if ((device->x_gc = DefaultGC(device->x_display, screen)) == NULL) {
|
||||
close_video_device(vdt_output, temp_idx);
|
||||
unlock;
|
||||
return vde_FailedStart;
|
||||
@ -586,14 +598,18 @@ __inline VideoDeviceError write_video_out(uint16_t width, uint16_t height,
|
||||
{
|
||||
VideoDevice *device = video_devices_running[vdt_output][0];
|
||||
|
||||
if ( !device ) return vde_DeviceNotActive;
|
||||
if (!device) {
|
||||
return vde_DeviceNotActive;
|
||||
}
|
||||
|
||||
if ( !device->x_window ) return vde_DeviceNotActive;
|
||||
if (!device->x_window) {
|
||||
return vde_DeviceNotActive;
|
||||
}
|
||||
|
||||
pthread_mutex_lock(device->mutex);
|
||||
|
||||
/* Resize X11 window to correct size */
|
||||
if ( device->video_width != width || device->video_height != height ) {
|
||||
if (device->video_width != width || device->video_height != height) {
|
||||
device->video_width = width;
|
||||
device->video_height = height;
|
||||
XResizeWindow(device->x_display, device->x_window, width, height);
|
||||
@ -638,7 +654,7 @@ __inline VideoDeviceError write_video_out(uint16_t width, uint16_t height,
|
||||
return vde_None;
|
||||
}
|
||||
|
||||
void *video_thread_poll (void *arg) // TODO: maybe use thread for every input source
|
||||
void *video_thread_poll(void *arg) // TODO: maybe use thread for every input source
|
||||
{
|
||||
/*
|
||||
* NOTE: We only need to poll input devices for data.
|
||||
@ -656,12 +672,13 @@ void *video_thread_poll (void *arg) // TODO: maybe use thread for every input so
|
||||
|
||||
unlock;
|
||||
|
||||
if ( video_thread_paused ) usleep(10000); /* Wait for unpause. */
|
||||
else {
|
||||
if (video_thread_paused) {
|
||||
usleep(10000); /* Wait for unpause. */
|
||||
} else {
|
||||
for (i = 0; i < size[vdt_input]; ++i) {
|
||||
lock;
|
||||
|
||||
if ( video_devices_running[vdt_input][i] != NULL ) {
|
||||
if (video_devices_running[vdt_input][i] != NULL) {
|
||||
/* Obtain frame image data from device buffers */
|
||||
VideoDevice *device = video_devices_running[vdt_input][i];
|
||||
uint16_t video_width = device->video_width;
|
||||
@ -672,7 +689,7 @@ void *video_thread_poll (void *arg) // TODO: maybe use thread for every input so
|
||||
|
||||
#if defined(__OSX__)
|
||||
|
||||
if ( osx_video_read_device(y, u, v, &video_width, &video_height) != 0 ) {
|
||||
if (osx_video_read_device(y, u, v, &video_width, &video_height) != 0) {
|
||||
unlock;
|
||||
continue;
|
||||
}
|
||||
@ -684,7 +701,7 @@ void *video_thread_poll (void *arg) // TODO: maybe use thread for every input so
|
||||
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
||||
buf.memory = V4L2_MEMORY_MMAP;
|
||||
|
||||
if ( -1 == ioctl(device->fd, VIDIOC_DQBUF, &buf) ) {
|
||||
if (-1 == ioctl(device->fd, VIDIOC_DQBUF, &buf)) {
|
||||
unlock;
|
||||
continue;
|
||||
}
|
||||
@ -697,8 +714,9 @@ void *video_thread_poll (void *arg) // TODO: maybe use thread for every input so
|
||||
#endif
|
||||
|
||||
/* Send frame data to friend through ToxAV */
|
||||
if ( device->cb )
|
||||
if (device->cb) {
|
||||
device->cb(video_width, video_height, y, u, v, device->cb_data);
|
||||
}
|
||||
|
||||
/* Convert YUV420 data to BGR */
|
||||
uint8_t *img_data = malloc(video_width * video_height * 4);
|
||||
@ -732,7 +750,7 @@ void *video_thread_poll (void *arg) // TODO: maybe use thread for every input so
|
||||
|
||||
#if defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
|
||||
|
||||
if ( -1 == xioctl(device->fd, VIDIOC_QBUF, &buf) ) {
|
||||
if (-1 == xioctl(device->fd, VIDIOC_QBUF, &buf)) {
|
||||
unlock;
|
||||
continue;
|
||||
}
|
||||
@ -753,34 +771,36 @@ void *video_thread_poll (void *arg) // TODO: maybe use thread for every input so
|
||||
|
||||
VideoDeviceError close_video_device(VideoDeviceType type, uint32_t device_idx)
|
||||
{
|
||||
if ( device_idx >= MAX_DEVICES ) return vde_InvalidSelection;
|
||||
if (device_idx >= MAX_DEVICES) {
|
||||
return vde_InvalidSelection;
|
||||
}
|
||||
|
||||
lock;
|
||||
VideoDevice *device = video_devices_running[type][device_idx];
|
||||
VideoDeviceError rc = vde_None;
|
||||
|
||||
if ( !device ) {
|
||||
if (!device) {
|
||||
unlock;
|
||||
return vde_DeviceNotActive;
|
||||
}
|
||||
|
||||
video_devices_running[type][device_idx] = NULL;
|
||||
|
||||
if ( !device->ref_count ) {
|
||||
if (!device->ref_count) {
|
||||
|
||||
if ( type == vdt_input ) {
|
||||
if (type == vdt_input) {
|
||||
#if defined(__OSX__)
|
||||
|
||||
osx_video_close_device(device_idx);
|
||||
#else /* not __OSX__ */
|
||||
enum v4l2_buf_type buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
||||
|
||||
if ( -1 == xioctl(device->fd, VIDIOC_STREAMOFF, &buf_type) ) {}
|
||||
if (-1 == xioctl(device->fd, VIDIOC_STREAMOFF, &buf_type)) {}
|
||||
|
||||
int i;
|
||||
|
||||
for (i = 0; i < device->n_buffers; ++i) {
|
||||
if ( -1 == munmap(device->buffers[i].start, device->buffers[i].length) ) {
|
||||
if (-1 == munmap(device->buffers[i].start, device->buffers[i].length)) {
|
||||
}
|
||||
}
|
||||
|
||||
@ -807,7 +827,9 @@ VideoDeviceError close_video_device(VideoDeviceType type, uint32_t device_idx)
|
||||
free(device);
|
||||
}
|
||||
|
||||
} else device->ref_count--;
|
||||
} else {
|
||||
device->ref_count--;
|
||||
}
|
||||
|
||||
unlock;
|
||||
return rc;
|
||||
@ -817,8 +839,9 @@ void print_video_devices(ToxWindow *self, VideoDeviceType type)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < size[type]; ++i)
|
||||
for (i = 0; i < size[type]; ++i) {
|
||||
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%d: %s", i, video_devices_names[type][i]);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
@ -45,8 +45,8 @@ typedef enum VideoDeviceError {
|
||||
vde_CaptureError = -9,
|
||||
} VideoDeviceError;
|
||||
|
||||
typedef void (*VideoDataHandleCallback) (int16_t width, int16_t height, const uint8_t *y, const uint8_t *u,
|
||||
const uint8_t *v, void *data);
|
||||
typedef void (*VideoDataHandleCallback)(int16_t width, int16_t height, const uint8_t *y, const uint8_t *u,
|
||||
const uint8_t *v, void *data);
|
||||
|
||||
#ifdef VIDEO
|
||||
VideoDeviceError init_video_devices(ToxAV *av);
|
||||
|
127
src/windows.c
127
src/windows.c
@ -67,21 +67,24 @@ void on_connectionchange(Tox *m, uint32_t friendnumber, TOX_CONNECTION connectio
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
|
||||
if (windows[i].onConnectionChange != NULL)
|
||||
if (windows[i].onConnectionChange != NULL) {
|
||||
windows[i].onConnectionChange(&windows[i], m, friendnumber, connection_status);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void on_typing_change(Tox *m, uint32_t friendnumber, bool is_typing, void *userdata)
|
||||
{
|
||||
if (user_settings->show_typing_other == SHOW_TYPING_OFF)
|
||||
if (user_settings->show_typing_other == SHOW_TYPING_OFF) {
|
||||
return;
|
||||
}
|
||||
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
|
||||
if (windows[i].onTypingChange != NULL)
|
||||
if (windows[i].onTypingChange != NULL) {
|
||||
windows[i].onTypingChange(&windows[i], m, friendnumber, is_typing);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -94,8 +97,9 @@ void on_message(Tox *m, uint32_t friendnumber, TOX_MESSAGE_TYPE type, const uint
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
|
||||
if (windows[i].onMessage != NULL)
|
||||
if (windows[i].onMessage != NULL) {
|
||||
windows[i].onMessage(&windows[i], m, friendnumber, type, msg, length);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -108,8 +112,9 @@ void on_nickchange(Tox *m, uint32_t friendnumber, const uint8_t *string, size_t
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
|
||||
if (windows[i].onNickChange != NULL)
|
||||
if (windows[i].onNickChange != NULL) {
|
||||
windows[i].onNickChange(&windows[i], m, friendnumber, nick, length);
|
||||
}
|
||||
}
|
||||
|
||||
store_data(m, DATA_FILE);
|
||||
@ -124,8 +129,9 @@ void on_statusmessagechange(Tox *m, uint32_t friendnumber, const uint8_t *string
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
|
||||
if (windows[i].onStatusMessageChange != NULL)
|
||||
if (windows[i].onStatusMessageChange != NULL) {
|
||||
windows[i].onStatusMessageChange(&windows[i], friendnumber, msg, length);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -134,8 +140,9 @@ void on_statuschange(Tox *m, uint32_t friendnumber, TOX_USER_STATUS status, void
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
|
||||
if (windows[i].onStatusChange != NULL)
|
||||
if (windows[i].onStatusChange != NULL) {
|
||||
windows[i].onStatusChange(&windows[i], m, friendnumber, status);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -144,8 +151,9 @@ void on_friendadded(Tox *m, uint32_t friendnumber, bool sort)
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
|
||||
if (windows[i].onFriendAdded != NULL)
|
||||
if (windows[i].onFriendAdded != NULL) {
|
||||
windows[i].onFriendAdded(&windows[i], m, friendnumber, sort);
|
||||
}
|
||||
}
|
||||
|
||||
store_data(m, DATA_FILE);
|
||||
@ -160,8 +168,9 @@ void on_groupmessage(Tox *m, uint32_t groupnumber, uint32_t peernumber, TOX_MESS
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
|
||||
if (windows[i].onGroupMessage != NULL)
|
||||
if (windows[i].onGroupMessage != NULL) {
|
||||
windows[i].onGroupMessage(&windows[i], m, groupnumber, peernumber, type, msg, length);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -171,8 +180,9 @@ void on_groupinvite(Tox *m, uint32_t friendnumber, TOX_CONFERENCE_TYPE type, con
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
|
||||
if (windows[i].onGroupInvite != NULL)
|
||||
if (windows[i].onGroupInvite != NULL) {
|
||||
windows[i].onGroupInvite(&windows[i], m, friendnumber, type, (char *) group_pub_key, length);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -181,8 +191,9 @@ void on_group_namelistchange(Tox *m, uint32_t groupnumber, void *userdata)
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
|
||||
if (windows[i].onGroupNameListChange != NULL)
|
||||
if (windows[i].onGroupNameListChange != NULL) {
|
||||
windows[i].onGroupNameListChange(&windows[i], m, groupnumber);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -196,8 +207,9 @@ void on_group_peernamechange(Tox *m, uint32_t groupnumber, uint32_t peernumber,
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
|
||||
if (windows[i].onGroupPeerNameChange != NULL)
|
||||
if (windows[i].onGroupPeerNameChange != NULL) {
|
||||
windows[i].onGroupPeerNameChange(&windows[i], m, groupnumber, peernumber, nick, length);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -210,8 +222,9 @@ void on_group_titlechange(Tox *m, uint32_t groupnumber, uint32_t peernumber, con
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
|
||||
if (windows[i].onGroupTitleChange != NULL)
|
||||
if (windows[i].onGroupTitleChange != NULL) {
|
||||
windows[i].onGroupTitleChange(&windows[i], m, groupnumber, peernumber, data, length);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -220,8 +233,9 @@ void on_file_chunk_request(Tox *m, uint32_t friendnumber, uint32_t filenumber, u
|
||||
{
|
||||
struct FileTransfer *ft = get_file_transfer_struct(friendnumber, filenumber);
|
||||
|
||||
if (!ft)
|
||||
if (!ft) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (ft->file_type == TOX_FILE_KIND_AVATAR) {
|
||||
on_avatar_chunk_request(m, ft, position, length);
|
||||
@ -231,8 +245,9 @@ void on_file_chunk_request(Tox *m, uint32_t friendnumber, uint32_t filenumber, u
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
|
||||
if (windows[i].onFileChunkRequest != NULL)
|
||||
if (windows[i].onFileChunkRequest != NULL) {
|
||||
windows[i].onFileChunkRequest(&windows[i], m, friendnumber, filenumber, position, length);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -241,14 +256,16 @@ void on_file_recv_chunk(Tox *m, uint32_t friendnumber, uint32_t filenumber, uint
|
||||
{
|
||||
struct FileTransfer *ft = get_file_transfer_struct(friendnumber, filenumber);
|
||||
|
||||
if (!ft)
|
||||
if (!ft) {
|
||||
return;
|
||||
}
|
||||
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
|
||||
if (windows[i].onFileRecvChunk != NULL)
|
||||
if (windows[i].onFileRecvChunk != NULL) {
|
||||
windows[i].onFileRecvChunk(&windows[i], m, friendnumber, filenumber, position, (char *) data, length);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -257,8 +274,9 @@ void on_file_control(Tox *m, uint32_t friendnumber, uint32_t filenumber, TOX_FIL
|
||||
{
|
||||
struct FileTransfer *ft = get_file_transfer_struct(friendnumber, filenumber);
|
||||
|
||||
if (!ft)
|
||||
if (!ft) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (ft->file_type == TOX_FILE_KIND_AVATAR) {
|
||||
on_avatar_file_control(m, ft, control);
|
||||
@ -268,8 +286,9 @@ void on_file_control(Tox *m, uint32_t friendnumber, uint32_t filenumber, TOX_FIL
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
|
||||
if (windows[i].onFileControl != NULL)
|
||||
if (windows[i].onFileControl != NULL) {
|
||||
windows[i].onFileControl(&windows[i], m, friendnumber, filenumber, control);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -296,27 +315,31 @@ void on_read_receipt(Tox *m, uint32_t friendnumber, uint32_t receipt, void *user
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
|
||||
if (windows[i].onReadReceipt != NULL)
|
||||
if (windows[i].onReadReceipt != NULL) {
|
||||
windows[i].onReadReceipt(&windows[i], m, friendnumber, receipt);
|
||||
}
|
||||
}
|
||||
}
|
||||
/* CALLBACKS END */
|
||||
|
||||
int add_window(Tox *m, ToxWindow w)
|
||||
{
|
||||
if (LINES < 2)
|
||||
if (LINES < 2) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; i++) {
|
||||
if (windows[i].active)
|
||||
if (windows[i].active) {
|
||||
continue;
|
||||
}
|
||||
|
||||
w.window = newwin(LINES - 2, COLS, 0, 0);
|
||||
|
||||
if (w.window == NULL)
|
||||
if (w.window == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
#ifdef URXVT_FIX
|
||||
/* Fixes text color problem on some terminals. */
|
||||
@ -324,8 +347,9 @@ int add_window(Tox *m, ToxWindow w)
|
||||
#endif
|
||||
windows[i] = w;
|
||||
|
||||
if (w.onInit)
|
||||
if (w.onInit) {
|
||||
w.onInit(&w, m);
|
||||
}
|
||||
|
||||
++num_active_windows;
|
||||
|
||||
@ -337,8 +361,9 @@ int add_window(Tox *m, ToxWindow w)
|
||||
|
||||
void set_active_window(int index)
|
||||
{
|
||||
if (index < 0 || index >= MAX_WINDOWS_NUM)
|
||||
if (index < 0 || index >= MAX_WINDOWS_NUM) {
|
||||
return;
|
||||
}
|
||||
|
||||
active_window = windows + index;
|
||||
}
|
||||
@ -351,16 +376,20 @@ void set_next_window(int ch)
|
||||
|
||||
while (true) {
|
||||
if (ch == user_settings->key_next_tab) {
|
||||
if (++active_window > end)
|
||||
if (++active_window > end) {
|
||||
active_window = windows;
|
||||
} else if (--active_window < windows)
|
||||
}
|
||||
} else if (--active_window < windows) {
|
||||
active_window = end;
|
||||
}
|
||||
|
||||
if (active_window->window)
|
||||
if (active_window->window) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (active_window == inf) /* infinite loop check */
|
||||
if (active_window == inf) { /* infinite loop check */
|
||||
exit_toxic_err("failed in set_next_window", FATALERR_INFLOOP);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -381,8 +410,9 @@ ToxWindow *init_windows(Tox *m)
|
||||
{
|
||||
int n_prompt = add_window(m, new_prompt());
|
||||
|
||||
if (n_prompt == -1 || add_window(m, new_friendlist()) == -1)
|
||||
if (n_prompt == -1 || add_window(m, new_friendlist()) == -1) {
|
||||
exit_toxic_err("failed in init_windows", FATALERR_WININIT);
|
||||
}
|
||||
|
||||
prompt = &windows[n_prompt];
|
||||
active_window = prompt;
|
||||
@ -401,14 +431,16 @@ void on_window_resize(void)
|
||||
getmaxyx(stdscr, y2, x2);
|
||||
y2 -= 2;
|
||||
|
||||
if (y2 <= 0 || x2 <= 0)
|
||||
if (y2 <= 0 || x2 <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
|
||||
if (!windows[i].active)
|
||||
if (!windows[i].active) {
|
||||
continue;
|
||||
}
|
||||
|
||||
ToxWindow *w = &windows[i];
|
||||
|
||||
@ -418,8 +450,9 @@ void on_window_resize(void)
|
||||
continue;
|
||||
}
|
||||
|
||||
if (w->help->active)
|
||||
if (w->help->active) {
|
||||
wclear(w->help->win);
|
||||
}
|
||||
|
||||
if (w->is_groupchat) {
|
||||
delwin(w->chatwin->sidebar);
|
||||
@ -441,8 +474,9 @@ void on_window_resize(void)
|
||||
} else {
|
||||
w->chatwin->history = subwin(w->window, y2 - CHATBOX_HEIGHT + 1, x2, 0, 0);
|
||||
|
||||
if (!w->is_groupchat)
|
||||
if (!w->is_groupchat) {
|
||||
w->stb->topline = subwin(w->window, 2, x2, 0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef AUDIO
|
||||
@ -462,7 +496,9 @@ static void draw_window_tab(ToxWindow *toxwin)
|
||||
{
|
||||
pthread_mutex_lock(&Winthread.lock);
|
||||
|
||||
if (toxwin->alert != WINDOW_ALERT_NONE) attron(COLOR_PAIR(toxwin->alert));
|
||||
if (toxwin->alert != WINDOW_ALERT_NONE) {
|
||||
attron(COLOR_PAIR(toxwin->alert));
|
||||
}
|
||||
|
||||
pthread_mutex_unlock(&Winthread.lock);
|
||||
|
||||
@ -471,7 +507,9 @@ static void draw_window_tab(ToxWindow *toxwin)
|
||||
|
||||
pthread_mutex_lock(&Winthread.lock);
|
||||
|
||||
if (toxwin->alert != WINDOW_ALERT_NONE) attroff(COLOR_PAIR(toxwin->alert));
|
||||
if (toxwin->alert != WINDOW_ALERT_NONE) {
|
||||
attroff(COLOR_PAIR(toxwin->alert));
|
||||
}
|
||||
|
||||
pthread_mutex_unlock(&Winthread.lock);
|
||||
}
|
||||
@ -492,8 +530,9 @@ static void draw_bar(void)
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
|
||||
if (!windows[i].active)
|
||||
if (!windows[i].active) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (windows + i == active_window)
|
||||
|
||||
@ -543,19 +582,22 @@ void draw_active_window(Tox *m)
|
||||
#ifdef HAVE_WIDECHAR
|
||||
int status = wget_wch(stdscr, &ch);
|
||||
|
||||
if (status == ERR)
|
||||
if (status == ERR) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (status == OK)
|
||||
if (status == OK) {
|
||||
ltr = iswprint(ch);
|
||||
else /* if (status == KEY_CODE_YES) */
|
||||
} else { /* if (status == KEY_CODE_YES) */
|
||||
ltr = false;
|
||||
}
|
||||
|
||||
#else
|
||||
ch = getch();
|
||||
|
||||
if (ch == ERR)
|
||||
if (ch == ERR) {
|
||||
return;
|
||||
}
|
||||
|
||||
/* TODO verify if this works */
|
||||
ltr = isprint(ch);
|
||||
@ -592,8 +634,9 @@ ToxWindow *get_window_ptr(int i)
|
||||
{
|
||||
ToxWindow *toxwin = NULL;
|
||||
|
||||
if (i >= 0 && i < MAX_WINDOWS_NUM && windows[i].active)
|
||||
if (i >= 0 && i < MAX_WINDOWS_NUM && windows[i].active) {
|
||||
toxwin = &windows[i];
|
||||
}
|
||||
|
||||
return toxwin;
|
||||
}
|
||||
|
101
src/xtra.c
101
src/xtra.c
@ -76,7 +76,9 @@ Property read_property(Window s, Atom p)
|
||||
|
||||
/* Keep trying to read the property until there are no bytes unread */
|
||||
do {
|
||||
if (data) XFree(data);
|
||||
if (data) {
|
||||
XFree(data);
|
||||
}
|
||||
|
||||
XGetWindowProperty(Xtra.display, s,
|
||||
p, 0,
|
||||
@ -98,7 +100,9 @@ Atom get_dnd_type(long *a, int l)
|
||||
int i = 0;
|
||||
|
||||
for (; i < l; i ++) {
|
||||
if (a[i] != XtraNil) return a[i]; /* Get first valid */
|
||||
if (a[i] != XtraNil) {
|
||||
return a[i]; /* Get first valid */
|
||||
}
|
||||
}
|
||||
|
||||
return XtraNil;
|
||||
@ -193,10 +197,11 @@ static void handle_xdnd_selection(XSelectionEvent *e)
|
||||
Property p = read_property(Xtra.proxy_window, XdndSelection);
|
||||
DropType dt;
|
||||
|
||||
if (strcmp(XGetAtomName(Xtra.display, p.read_type), "text/uri-list") == 0)
|
||||
if (strcmp(XGetAtomName(Xtra.display, p.read_type), "text/uri-list") == 0) {
|
||||
dt = DT_file_list;
|
||||
else /* text/uri-list */
|
||||
} else { /* text/uri-list */
|
||||
dt = DT_plain;
|
||||
}
|
||||
|
||||
|
||||
/* Call callback for every entry */
|
||||
@ -204,13 +209,18 @@ static void handle_xdnd_selection(XSelectionEvent *e)
|
||||
char *sptr;
|
||||
char *str = strtok_r((char *) p.data, "\n\r", &sptr);
|
||||
|
||||
if (str) Xtra.on_drop(str, dt);
|
||||
|
||||
while ((str = strtok_r(NULL, "\n\r", &sptr)))
|
||||
if (str) {
|
||||
Xtra.on_drop(str, dt);
|
||||
}
|
||||
|
||||
while ((str = strtok_r(NULL, "\n\r", &sptr))) {
|
||||
Xtra.on_drop(str, dt);
|
||||
}
|
||||
}
|
||||
|
||||
if (p.data) XFree(p.data);
|
||||
if (p.data) {
|
||||
XFree(p.data);
|
||||
}
|
||||
}
|
||||
|
||||
void *event_loop(void *p)
|
||||
@ -227,7 +237,9 @@ void *event_loop(void *p)
|
||||
|
||||
XLockDisplay(Xtra.display);
|
||||
|
||||
if ((pending = XPending(Xtra.display))) XNextEvent(Xtra.display, &event);
|
||||
if ((pending = XPending(Xtra.display))) {
|
||||
XNextEvent(Xtra.display, &event);
|
||||
}
|
||||
|
||||
if (!pending) {
|
||||
XUnlockDisplay(Xtra.display);
|
||||
@ -238,13 +250,22 @@ void *event_loop(void *p)
|
||||
if (event.type == ClientMessage) {
|
||||
Atom type = event.xclient.message_type;
|
||||
|
||||
if (type == XdndEnter) handle_xdnd_enter(&event.xclient);
|
||||
else if (type == XdndPosition) handle_xdnd_position(&event.xclient);
|
||||
else if (type == XdndDrop) handle_xdnd_drop(&event.xclient);
|
||||
else if (type == XtraTerminate) break;
|
||||
} else if (event.type == SelectionNotify) handle_xdnd_selection(&event.xselection);
|
||||
if (type == XdndEnter) {
|
||||
handle_xdnd_enter(&event.xclient);
|
||||
} else if (type == XdndPosition) {
|
||||
handle_xdnd_position(&event.xclient);
|
||||
} else if (type == XdndDrop) {
|
||||
handle_xdnd_drop(&event.xclient);
|
||||
} else if (type == XtraTerminate) {
|
||||
break;
|
||||
}
|
||||
} else if (event.type == SelectionNotify) {
|
||||
handle_xdnd_selection(&event.xselection);
|
||||
}
|
||||
/* AINNOBODYCANHANDLEDEMEVENTS*/
|
||||
else XSendEvent(Xtra.display, Xtra.terminal_window, 0, 0, &event);
|
||||
else {
|
||||
XSendEvent(Xtra.display, Xtra.terminal_window, 0, 0, &event);
|
||||
}
|
||||
|
||||
XUnlockDisplay(Xtra.display);
|
||||
}
|
||||
@ -253,7 +274,9 @@ void *event_loop(void *p)
|
||||
* Please call xtra_terminate() at exit
|
||||
* otherwise HEWUSAGUDBOI happens
|
||||
*/
|
||||
if (Xtra.display) XCloseDisplay(Xtra.display);
|
||||
if (Xtra.display) {
|
||||
XCloseDisplay(Xtra.display);
|
||||
}
|
||||
|
||||
return (Xtra.display = NULL);
|
||||
}
|
||||
@ -262,19 +285,25 @@ int init_xtra(drop_callback d)
|
||||
{
|
||||
memset(&Xtra, 0, sizeof(Xtra));
|
||||
|
||||
if (!d) return -1;
|
||||
else Xtra.on_drop = d;
|
||||
if (!d) {
|
||||
return -1;
|
||||
} else {
|
||||
Xtra.on_drop = d;
|
||||
}
|
||||
|
||||
XInitThreads();
|
||||
|
||||
if ( !(Xtra.display = XOpenDisplay(NULL))) return -1;
|
||||
if (!(Xtra.display = XOpenDisplay(NULL))) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
Xtra.terminal_window = focused_window_id();
|
||||
|
||||
/* OSX: if focused window is 0, it means toxic is ran from
|
||||
* native terminal and not X11 terminal window, silently exit */
|
||||
if (!Xtra.terminal_window)
|
||||
if (!Xtra.terminal_window) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
{
|
||||
/* Create an invisible window which will act as proxy for the DnD operation. */
|
||||
@ -299,17 +328,18 @@ int init_xtra(drop_callback d)
|
||||
XDefaultRootWindow(Xtra.display),
|
||||
&root, &x, &y, &wht, &hht, &b, &d);
|
||||
|
||||
if (! (Xtra.proxy_window = XCreateWindow
|
||||
(Xtra.display, Xtra.terminal_window, /* Parent */
|
||||
0, 0, /* Position */
|
||||
wht, hht, /* Width + height */
|
||||
0, /* Border width */
|
||||
CopyFromParent, /* Depth */
|
||||
InputOnly, /* Class */
|
||||
CopyFromParent, /* Visual */
|
||||
CWEventMask | CWCursor, /* Value mask */
|
||||
&attr)) ) /* Attributes for value mask */
|
||||
if (!(Xtra.proxy_window = XCreateWindow
|
||||
(Xtra.display, Xtra.terminal_window, /* Parent */
|
||||
0, 0, /* Position */
|
||||
wht, hht, /* Width + height */
|
||||
0, /* Border width */
|
||||
CopyFromParent, /* Depth */
|
||||
InputOnly, /* Class */
|
||||
CopyFromParent, /* Visual */
|
||||
CWEventMask | CWCursor, /* Value mask */
|
||||
&attr))) { /* Attributes for value mask */
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
XMapWindow(Xtra.display, Xtra.proxy_window); /* Show window (sandwich) */
|
||||
@ -339,8 +369,9 @@ int init_xtra(drop_callback d)
|
||||
|
||||
pthread_t id;
|
||||
|
||||
if (pthread_create(&id, NULL, event_loop, NULL) != 0)
|
||||
if (pthread_create(&id, NULL, event_loop, NULL) != 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
pthread_detach(id);
|
||||
|
||||
@ -349,7 +380,9 @@ int init_xtra(drop_callback d)
|
||||
|
||||
void terminate_xtra()
|
||||
{
|
||||
if (!Xtra.display || !Xtra.terminal_window) return;
|
||||
if (!Xtra.display || !Xtra.terminal_window) {
|
||||
return;
|
||||
}
|
||||
|
||||
XEvent terminate = {
|
||||
.xclient = {
|
||||
@ -369,7 +402,9 @@ void terminate_xtra()
|
||||
|
||||
long unsigned int focused_window_id()
|
||||
{
|
||||
if (!Xtra.display) return 0;
|
||||
if (!Xtra.display) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
Window focus;
|
||||
int revert;
|
||||
|
@ -31,7 +31,7 @@ typedef enum {
|
||||
}
|
||||
DropType;
|
||||
|
||||
typedef void (*drop_callback) (const char *, DropType);
|
||||
typedef void (*drop_callback)(const char *, DropType);
|
||||
|
||||
int init_xtra(drop_callback d);
|
||||
void terminate_xtra();
|
||||
|
Loading…
Reference in New Issue
Block a user