2012-11-22 19:19:29 -05:00
/*
* window . c
2019-11-13 06:11:05 -05:00
* vim : expandtab : ts = 4 : sts = 4 : sw = 4
2012-11-22 19:19:29 -05:00
*
2019-01-22 05:31:45 -05:00
* Copyright ( C ) 2012 - 2019 James Booth < boothj5 @ gmail . com >
2020-02-10 07:19:54 -05:00
* Copyright ( C ) 2019 - 2020 Michael Vetter < jubalh @ iodoru . org >
2012-11-22 19:19:29 -05:00
*
* This file is part of Profanity .
*
* Profanity is free software : you can redistribute it and / or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation , either version 3 of the License , or
* ( at your option ) any later version .
*
* Profanity is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU General Public License for more details .
*
* You should have received a copy of the GNU General Public License
2016-07-23 20:14:49 -04:00
* along with Profanity . If not , see < https : //www.gnu.org/licenses/>.
2012-11-22 19:19:29 -05:00
*
2014-08-24 15:57:39 -04:00
* In addition , as a special exception , the copyright holders give permission to
* link the code of portions of this program with the OpenSSL library under
* certain conditions as described in each individual source file , and
* distribute linked combinations including the two .
*
* You must obey the GNU General Public License in all respects for all of the
* code used other than OpenSSL . If you modify file ( s ) with this exception , you
* may extend this exception to your version of the file ( s ) , but you are not
* obligated to do so . If you do not wish to do so , delete this exception
* statement from your version . If you delete this exception statement from all
* source files in the program , then also delete it here .
*
2012-11-22 19:19:29 -05:00
*/
2016-03-31 16:05:02 -04:00
# include "config.h"
2012-11-22 19:19:29 -05:00
# include <stdlib.h>
# include <string.h>
2015-01-27 20:55:16 -05:00
# include <time.h>
2014-01-08 15:11:53 -05:00
# include <assert.h>
2015-01-31 19:14:11 -05:00
# include <wchar.h>
2012-11-22 19:19:29 -05:00
# include <glib.h>
2016-07-24 10:43:51 -04:00
2016-03-31 16:05:02 -04:00
# ifdef HAVE_NCURSESW_NCURSES_H
2013-01-02 15:27:37 -05:00
# include <ncursesw/ncurses.h>
2016-03-31 16:05:02 -04:00
# elif HAVE_NCURSES_H
2013-01-03 19:35:54 -05:00
# include <ncurses.h>
2012-11-22 19:19:29 -05:00
# endif
2020-02-10 07:19:54 -05:00
# include "log.h"
2013-02-02 16:59:29 -05:00
# include "config/theme.h"
2014-10-09 17:02:39 -04:00
# include "config/preferences.h"
2014-10-07 12:06:02 -04:00
# include "ui/ui.h"
2013-02-02 15:55:58 -05:00
# include "ui/window.h"
2016-09-22 19:56:53 -04:00
# include "ui/screen.h"
2014-06-03 16:14:21 -04:00
# include "xmpp/xmpp.h"
2016-07-24 10:43:51 -04:00
# include "xmpp/roster_list.h"
2012-11-22 19:19:29 -05:00
2014-12-21 17:01:56 -05:00
# define CONS_WIN_TITLE "Profanity. Type / help for help information."
2014-12-14 19:28:28 -05:00
# define XML_WIN_TITLE "XML Console"
2014-11-15 17:26:43 -05:00
# define CEILING(X) (X-(int)(X) > 0 ? (int)(X+1) : (int)(X))
2020-02-10 07:19:54 -05:00
static void _win_printf ( ProfWin * window , const char show_char , int pad_indent , GDateTime * timestamp , int flags , theme_item_t theme_item , const char * const from , const char * const message_id , const char * const message , . . . ) ;
2020-02-12 02:32:34 -05:00
static void _win_print_internal ( ProfWin * window , const char show_char , int pad_indent , GDateTime * time ,
2015-10-25 19:31:11 -04:00
int flags , theme_item_t theme_item , const char * const from , const char * const message , DeliveryReceipt * receipt ) ;
static void _win_print_wrapped ( WINDOW * win , const char * const message , size_t indent , int pad_indent ) ;
2014-07-20 18:35:48 -04:00
2014-11-10 17:47:53 -05:00
int
2014-11-15 17:26:43 -05:00
win_roster_cols ( void )
2014-11-10 17:47:53 -05:00
{
2014-11-15 18:47:27 -05:00
int roster_win_percent = prefs_get_roster_size ( ) ;
2014-11-10 17:47:53 -05:00
int cols = getmaxx ( stdscr ) ;
2014-11-15 17:26:43 -05:00
return CEILING ( ( ( ( double ) cols ) / 100 ) * roster_win_percent ) ;
2014-11-10 17:47:53 -05:00
}
2014-07-20 18:35:48 -04:00
2014-11-15 17:59:13 -05:00
int
win_occpuants_cols ( void )
{
2014-11-15 18:47:27 -05:00
int occupants_win_percent = prefs_get_occupants_size ( ) ;
2014-11-15 17:59:13 -05:00
int cols = getmaxx ( stdscr ) ;
return CEILING ( ( ( ( double ) cols ) / 100 ) * occupants_win_percent ) ;
}
2014-12-16 15:53:23 -05:00
static ProfLayout *
_win_create_simple_layout ( void )
2014-12-14 19:28:28 -05:00
{
int cols = getmaxx ( stdscr ) ;
2014-12-16 15:53:23 -05:00
ProfLayoutSimple * layout = malloc ( sizeof ( ProfLayoutSimple ) ) ;
2014-12-21 14:40:15 -05:00
layout - > base . type = LAYOUT_SIMPLE ;
layout - > base . win = newpad ( PAD_SIZE , cols ) ;
wbkgd ( layout - > base . win , theme_attrs ( THEME_TEXT ) ) ;
layout - > base . buffer = buffer_create ( ) ;
layout - > base . y_pos = 0 ;
layout - > base . paged = 0 ;
scrollok ( layout - > base . win , TRUE ) ;
return & layout - > base ;
2014-12-16 15:53:23 -05:00
}
static ProfLayout *
_win_create_split_layout ( void )
{
int cols = getmaxx ( stdscr ) ;
2014-12-15 20:39:47 -05:00
ProfLayoutSplit * layout = malloc ( sizeof ( ProfLayoutSplit ) ) ;
2014-12-21 14:40:15 -05:00
layout - > base . type = LAYOUT_SPLIT ;
layout - > base . win = newpad ( PAD_SIZE , cols ) ;
wbkgd ( layout - > base . win , theme_attrs ( THEME_TEXT ) ) ;
layout - > base . buffer = buffer_create ( ) ;
layout - > base . y_pos = 0 ;
layout - > base . paged = 0 ;
scrollok ( layout - > base . win , TRUE ) ;
2014-12-15 20:39:47 -05:00
layout - > subwin = NULL ;
layout - > sub_y_pos = 0 ;
2014-12-16 17:14:15 -05:00
layout - > memcheck = LAYOUT_SPLIT_MEMCHECK ;
2014-12-15 20:39:47 -05:00
2014-12-21 14:40:15 -05:00
return & layout - > base ;
2014-12-16 15:53:23 -05:00
}
2014-12-15 20:39:47 -05:00
2014-12-16 15:53:23 -05:00
ProfWin *
win_create_console ( void )
{
ProfConsoleWin * new_win = malloc ( sizeof ( ProfConsoleWin ) ) ;
2014-12-21 14:40:15 -05:00
new_win - > window . type = WIN_CONSOLE ;
new_win - > window . layout = _win_create_split_layout ( ) ;
2014-12-16 15:53:23 -05:00
2014-12-21 14:40:15 -05:00
return & new_win - > window ;
2014-12-14 19:28:28 -05:00
}
2014-12-10 17:34:33 -05:00
ProfWin *
2015-10-25 19:31:11 -04:00
win_create_chat ( const char * const barejid )
2014-12-10 17:34:33 -05:00
{
2014-12-15 20:39:47 -05:00
ProfChatWin * new_win = malloc ( sizeof ( ProfChatWin ) ) ;
2014-12-21 14:40:15 -05:00
new_win - > window . type = WIN_CHAT ;
new_win - > window . layout = _win_create_simple_layout ( ) ;
2014-12-10 17:34:33 -05:00
2014-12-18 18:57:19 -05:00
new_win - > barejid = strdup ( barejid ) ;
2015-01-10 13:17:10 -05:00
new_win - > resource_override = NULL ;
2015-08-29 20:32:13 -04:00
new_win - > is_otr = FALSE ;
2015-06-12 20:13:56 -04:00
new_win - > otr_is_trusted = FALSE ;
2015-08-29 20:32:13 -04:00
new_win - > pgp_recv = FALSE ;
new_win - > pgp_send = FALSE ;
2019-02-19 13:23:50 -05:00
new_win - > is_omemo = FALSE ;
2014-12-15 20:39:47 -05:00
new_win - > history_shown = FALSE ;
2014-12-21 18:14:01 -05:00
new_win - > unread = 0 ;
2015-01-11 15:20:17 -05:00
new_win - > state = chat_state_new ( ) ;
2017-01-19 17:33:29 -05:00
new_win - > enctext = NULL ;
2017-01-20 16:03:55 -05:00
new_win - > incoming_char = NULL ;
new_win - > outgoing_char = NULL ;
2020-02-10 10:17:01 -05:00
new_win - > last_message = NULL ;
new_win - > last_msg_id = NULL ;
2014-12-10 17:34:33 -05:00
2014-12-19 19:52:35 -05:00
new_win - > memcheck = PROFCHATWIN_MEMCHECK ;
2014-12-21 14:40:15 -05:00
return & new_win - > window ;
2014-12-10 17:34:33 -05:00
}
2014-12-14 19:28:28 -05:00
ProfWin *
2015-10-25 19:31:11 -04:00
win_create_muc ( const char * const roomjid )
2014-12-14 19:28:28 -05:00
{
2014-12-15 20:39:47 -05:00
ProfMucWin * new_win = malloc ( sizeof ( ProfMucWin ) ) ;
2014-12-14 19:28:28 -05:00
int cols = getmaxx ( stdscr ) ;
2014-12-21 14:40:15 -05:00
new_win - > window . type = WIN_MUC ;
2018-03-09 16:11:59 -05:00
new_win - > window . layout = _win_create_simple_layout ( ) ;
2014-12-15 20:39:47 -05:00
ProfLayoutSplit * layout = malloc ( sizeof ( ProfLayoutSplit ) ) ;
2014-12-21 14:40:15 -05:00
layout - > base . type = LAYOUT_SPLIT ;
2014-12-14 19:28:28 -05:00
if ( prefs_get_boolean ( PREF_OCCUPANTS ) ) {
int subwin_cols = win_occpuants_cols ( ) ;
2014-12-21 14:40:15 -05:00
layout - > base . win = newpad ( PAD_SIZE , cols - subwin_cols ) ;
wbkgd ( layout - > base . win , theme_attrs ( THEME_TEXT ) ) ;
2014-12-15 20:39:47 -05:00
layout - > subwin = newpad ( PAD_SIZE , subwin_cols ) ; ;
wbkgd ( layout - > subwin , theme_attrs ( THEME_TEXT ) ) ;
2014-12-14 19:28:28 -05:00
} else {
2014-12-21 14:40:15 -05:00
layout - > base . win = newpad ( PAD_SIZE , ( cols ) ) ;
wbkgd ( layout - > base . win , theme_attrs ( THEME_TEXT ) ) ;
2014-12-15 20:39:47 -05:00
layout - > subwin = NULL ;
}
layout - > sub_y_pos = 0 ;
2014-12-16 17:14:15 -05:00
layout - > memcheck = LAYOUT_SPLIT_MEMCHECK ;
2014-12-21 14:40:15 -05:00
layout - > base . buffer = buffer_create ( ) ;
layout - > base . y_pos = 0 ;
layout - > base . paged = 0 ;
scrollok ( layout - > base . win , TRUE ) ;
new_win - > window . layout = ( ProfLayout * ) layout ;
2014-12-15 20:39:47 -05:00
2014-12-18 18:57:19 -05:00
new_win - > roomjid = strdup ( roomjid ) ;
2020-01-23 12:22:36 -05:00
new_win - > room_name = NULL ;
2014-12-21 18:14:01 -05:00
new_win - > unread = 0 ;
2016-01-24 19:19:26 -05:00
new_win - > unread_mentions = FALSE ;
new_win - > unread_triggers = FALSE ;
2015-04-11 21:14:37 -04:00
if ( prefs_get_boolean ( PREF_OCCUPANTS_JID ) ) {
new_win - > showjid = TRUE ;
} else {
new_win - > showjid = FALSE ;
}
2017-01-20 18:26:14 -05:00
new_win - > enctext = NULL ;
new_win - > message_char = NULL ;
2019-03-18 14:50:28 -04:00
new_win - > is_omemo = FALSE ;
2020-02-12 08:06:00 -05:00
new_win - > last_message = NULL ;
new_win - > last_msg_id = NULL ;
2014-12-15 20:39:47 -05:00
2014-12-19 19:52:35 -05:00
new_win - > memcheck = PROFMUCWIN_MEMCHECK ;
2014-12-21 14:40:15 -05:00
return & new_win - > window ;
2014-12-14 19:28:28 -05:00
}
ProfWin *
2018-06-20 12:10:44 -04:00
win_create_config ( const char * const roomjid , DataForm * form , ProfConfWinCallback submit , ProfConfWinCallback cancel , const void * userdata )
2014-12-14 19:28:28 -05:00
{
2018-04-11 12:57:50 -04:00
ProfConfWin * new_win = malloc ( sizeof ( ProfConfWin ) ) ;
new_win - > window . type = WIN_CONFIG ;
2014-12-21 14:40:15 -05:00
new_win - > window . layout = _win_create_simple_layout ( ) ;
2014-12-21 17:01:56 -05:00
new_win - > roomjid = strdup ( roomjid ) ;
2014-12-15 20:39:47 -05:00
new_win - > form = form ;
2018-05-30 13:25:06 -04:00
new_win - > submit = submit ;
new_win - > cancel = cancel ;
2018-06-20 12:10:44 -04:00
new_win - > userdata = userdata ;
2014-12-14 19:28:28 -05:00
2014-12-19 19:52:35 -05:00
new_win - > memcheck = PROFCONFWIN_MEMCHECK ;
2014-12-21 14:40:15 -05:00
return & new_win - > window ;
2014-12-14 19:28:28 -05:00
}
2014-12-10 17:34:33 -05:00
ProfWin *
2015-10-25 19:31:11 -04:00
win_create_private ( const char * const fulljid )
2014-12-10 17:34:33 -05:00
{
2014-12-15 20:39:47 -05:00
ProfPrivateWin * new_win = malloc ( sizeof ( ProfPrivateWin ) ) ;
2014-12-21 14:40:15 -05:00
new_win - > window . type = WIN_PRIVATE ;
new_win - > window . layout = _win_create_simple_layout ( ) ;
2014-12-18 18:57:19 -05:00
new_win - > fulljid = strdup ( fulljid ) ;
2014-12-21 18:14:01 -05:00
new_win - > unread = 0 ;
2016-02-02 16:52:13 -05:00
new_win - > occupant_offline = FALSE ;
2016-02-02 19:11:38 -05:00
new_win - > room_left = FALSE ;
2014-12-18 18:57:19 -05:00
2014-12-19 19:52:35 -05:00
new_win - > memcheck = PROFPRIVATEWIN_MEMCHECK ;
2014-12-21 14:40:15 -05:00
return & new_win - > window ;
2014-12-10 17:34:33 -05:00
}
2012-11-22 19:19:29 -05:00
ProfWin *
2014-12-14 19:28:28 -05:00
win_create_xmlconsole ( void )
2012-11-22 19:19:29 -05:00
{
2014-12-15 20:39:47 -05:00
ProfXMLWin * new_win = malloc ( sizeof ( ProfXMLWin ) ) ;
2014-12-21 14:40:15 -05:00
new_win - > window . type = WIN_XML ;
new_win - > window . layout = _win_create_simple_layout ( ) ;
2014-12-09 20:14:11 -05:00
2014-12-21 17:01:56 -05:00
new_win - > memcheck = PROFXMLWIN_MEMCHECK ;
2014-12-18 18:57:19 -05:00
2014-12-21 14:40:15 -05:00
return & new_win - > window ;
2012-11-22 19:19:29 -05:00
}
2016-02-14 17:28:55 -05:00
ProfWin *
2016-07-11 21:16:12 -04:00
win_create_plugin ( const char * const plugin_name , const char * const tag )
2016-02-14 17:28:55 -05:00
{
ProfPluginWin * new_win = malloc ( sizeof ( ProfPluginWin ) ) ;
2018-03-08 14:55:17 -05:00
new_win - > window . type = WIN_PLUGIN ;
new_win - > window . layout = _win_create_simple_layout ( ) ;
2016-02-14 17:28:55 -05:00
new_win - > tag = strdup ( tag ) ;
2016-07-11 21:16:12 -04:00
new_win - > plugin_name = strdup ( plugin_name ) ;
2016-02-14 17:28:55 -05:00
new_win - > memcheck = PROFPLUGINWIN_MEMCHECK ;
2018-03-08 14:55:17 -05:00
return & new_win - > window ;
2016-02-14 17:28:55 -05:00
}
2015-10-25 19:31:11 -04:00
char *
2014-12-21 17:01:56 -05:00
win_get_title ( ProfWin * window )
{
if ( window = = NULL ) {
return strdup ( CONS_WIN_TITLE ) ;
}
if ( window - > type = = WIN_CONSOLE ) {
return strdup ( CONS_WIN_TITLE ) ;
}
if ( window - > type = = WIN_CHAT ) {
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2016-01-04 19:06:50 -05:00
if ( conn_status = = JABBER_CONNECTED ) {
PContact contact = roster_get_contact ( chatwin - > barejid ) ;
if ( contact ) {
const char * name = p_contact_name_or_jid ( contact ) ;
return strdup ( name ) ;
} else {
return strdup ( chatwin - > barejid ) ;
}
2014-12-21 17:39:00 -05:00
} else {
return strdup ( chatwin - > barejid ) ;
}
2014-12-21 17:01:56 -05:00
}
if ( window - > type = = WIN_MUC ) {
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
return strdup ( mucwin - > roomjid ) ;
}
2018-04-11 12:57:50 -04:00
if ( window - > type = = WIN_CONFIG ) {
ProfConfWin * confwin = ( ProfConfWin * ) window ;
2014-12-21 17:01:56 -05:00
assert ( confwin - > memcheck = = PROFCONFWIN_MEMCHECK ) ;
GString * title = g_string_new ( confwin - > roomjid ) ;
g_string_append ( title , " config " ) ;
if ( confwin - > form - > modified ) {
g_string_append ( title , " * " ) ;
}
char * title_str = title - > str ;
g_string_free ( title , FALSE ) ;
return title_str ;
}
if ( window - > type = = WIN_PRIVATE ) {
ProfPrivateWin * privatewin = ( ProfPrivateWin * ) window ;
assert ( privatewin - > memcheck = = PROFPRIVATEWIN_MEMCHECK ) ;
return strdup ( privatewin - > fulljid ) ;
}
if ( window - > type = = WIN_XML ) {
return strdup ( XML_WIN_TITLE ) ;
}
2016-02-14 17:28:55 -05:00
if ( window - > type = = WIN_PLUGIN ) {
ProfPluginWin * pluginwin = ( ProfPluginWin * ) window ;
assert ( pluginwin - > memcheck = = PROFPLUGINWIN_MEMCHECK ) ;
return strdup ( pluginwin - > tag ) ;
}
2014-12-21 17:01:56 -05:00
return NULL ;
}
2018-03-09 16:11:59 -05:00
char *
win_get_tab_identifier ( ProfWin * window )
{
assert ( window ! = NULL ) ;
switch ( window - > type ) {
case WIN_CONSOLE :
{
return strdup ( " console " ) ;
}
case WIN_CHAT :
{
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
return strdup ( chatwin - > barejid ) ;
}
case WIN_MUC :
{
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
return strdup ( mucwin - > roomjid ) ;
}
2018-04-11 12:57:50 -04:00
case WIN_CONFIG :
2018-03-09 16:11:59 -05:00
{
2018-04-11 12:57:50 -04:00
ProfConfWin * confwin = ( ProfConfWin * ) window ;
return strdup ( confwin - > roomjid ) ;
2018-03-09 16:11:59 -05:00
}
case WIN_PRIVATE :
{
ProfPrivateWin * privwin = ( ProfPrivateWin * ) window ;
return strdup ( privwin - > fulljid ) ;
}
case WIN_PLUGIN :
{
ProfPluginWin * pluginwin = ( ProfPluginWin * ) window ;
return strdup ( pluginwin - > tag ) ;
}
case WIN_XML :
{
return strdup ( " xmlconsole " ) ;
}
default :
return strdup ( " UNKNOWN " ) ;
}
}
2015-11-29 18:58:52 -05:00
char *
2016-10-15 11:41:37 -04:00
win_to_string ( ProfWin * window )
2015-11-29 18:58:52 -05:00
{
assert ( window ! = NULL ) ;
switch ( window - > type ) {
case WIN_CONSOLE :
{
ProfConsoleWin * conswin = ( ProfConsoleWin * ) window ;
return cons_get_string ( conswin ) ;
}
case WIN_CHAT :
{
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
return chatwin_get_string ( chatwin ) ;
}
case WIN_MUC :
{
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
return mucwin_get_string ( mucwin ) ;
}
2018-04-11 12:57:50 -04:00
case WIN_CONFIG :
2015-11-29 18:58:52 -05:00
{
2018-04-11 12:57:50 -04:00
ProfConfWin * confwin = ( ProfConfWin * ) window ;
return confwin_get_string ( confwin ) ;
2015-11-29 18:58:52 -05:00
}
case WIN_PRIVATE :
{
ProfPrivateWin * privwin = ( ProfPrivateWin * ) window ;
return privwin_get_string ( privwin ) ;
}
case WIN_XML :
{
ProfXMLWin * xmlwin = ( ProfXMLWin * ) window ;
return xmlwin_get_string ( xmlwin ) ;
}
2016-02-14 17:28:55 -05:00
case WIN_PLUGIN :
{
ProfPluginWin * pluginwin = ( ProfPluginWin * ) window ;
GString * gstring = g_string_new ( " " ) ;
2016-02-29 19:03:11 -05:00
g_string_append_printf ( gstring , " Plugin: %s " , pluginwin - > tag ) ;
2016-02-14 17:28:55 -05:00
char * res = gstring - > str ;
g_string_free ( gstring , FALSE ) ;
return res ;
}
2015-11-29 18:58:52 -05:00
default :
return NULL ;
}
}
2014-10-09 16:27:16 -04:00
void
win_hide_subwin ( ProfWin * window )
{
2014-12-15 20:39:47 -05:00
if ( window - > layout - > type = = LAYOUT_SPLIT ) {
ProfLayoutSplit * layout = ( ProfLayoutSplit * ) window - > layout ;
if ( layout - > subwin ) {
delwin ( layout - > subwin ) ;
2014-12-09 19:54:46 -05:00
}
2014-12-15 20:39:47 -05:00
layout - > subwin = NULL ;
layout - > sub_y_pos = 0 ;
int cols = getmaxx ( stdscr ) ;
2014-12-21 14:40:15 -05:00
wresize ( layout - > base . win , PAD_SIZE , cols ) ;
2014-12-15 20:39:47 -05:00
win_redraw ( window ) ;
} else {
int cols = getmaxx ( stdscr ) ;
wresize ( window - > layout - > win , PAD_SIZE , cols ) ;
win_redraw ( window ) ;
2014-10-09 16:27:16 -04:00
}
}
2014-10-09 16:42:09 -04:00
void
win_show_subwin ( ProfWin * window )
{
2014-12-09 19:54:46 -05:00
int cols = getmaxx ( stdscr ) ;
int subwin_cols = 0 ;
2014-10-09 16:42:09 -04:00
2014-12-20 17:44:01 -05:00
if ( window - > layout - > type ! = LAYOUT_SPLIT ) {
return ;
}
if ( window - > type = = WIN_MUC ) {
subwin_cols = win_occpuants_cols ( ) ;
} else if ( window - > type = = WIN_CONSOLE ) {
2014-12-09 19:54:46 -05:00
subwin_cols = win_roster_cols ( ) ;
2014-10-09 16:42:09 -04:00
}
2014-12-20 17:44:01 -05:00
ProfLayoutSplit * layout = ( ProfLayoutSplit * ) window - > layout ;
layout - > subwin = newpad ( PAD_SIZE , subwin_cols ) ;
wbkgd ( layout - > subwin , theme_attrs ( THEME_TEXT ) ) ;
2014-12-21 14:40:15 -05:00
wresize ( layout - > base . win , PAD_SIZE , cols - subwin_cols ) ;
2014-12-20 17:44:01 -05:00
win_redraw ( window ) ;
2014-10-09 16:42:09 -04:00
}
2012-11-22 19:19:29 -05:00
void
2013-04-21 14:48:56 -04:00
win_free ( ProfWin * window )
2012-11-22 19:19:29 -05:00
{
2014-12-15 20:39:47 -05:00
if ( window - > layout - > type = = LAYOUT_SPLIT ) {
ProfLayoutSplit * layout = ( ProfLayoutSplit * ) window - > layout ;
if ( layout - > subwin ) {
delwin ( layout - > subwin ) ;
2014-12-09 19:54:46 -05:00
}
2014-12-21 14:40:15 -05:00
buffer_free ( layout - > base . buffer ) ;
delwin ( layout - > base . win ) ;
2014-12-15 20:39:47 -05:00
} else {
buffer_free ( window - > layout - > buffer ) ;
delwin ( window - > layout - > win ) ;
2014-10-07 12:06:02 -04:00
}
2015-02-06 16:39:53 -05:00
free ( window - > layout ) ;
2014-12-09 19:54:46 -05:00
2016-03-07 13:24:04 -05:00
switch ( window - > type ) {
case WIN_CHAT :
{
2014-12-15 20:39:47 -05:00
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
2014-12-18 18:57:19 -05:00
free ( chatwin - > barejid ) ;
2015-01-10 13:17:10 -05:00
free ( chatwin - > resource_override ) ;
2017-01-19 17:33:29 -05:00
free ( chatwin - > enctext ) ;
2017-01-20 16:03:55 -05:00
free ( chatwin - > incoming_char ) ;
free ( chatwin - > outgoing_char ) ;
2020-02-10 10:17:01 -05:00
free ( chatwin - > last_message ) ;
free ( chatwin - > last_msg_id ) ;
2015-02-09 15:11:51 -05:00
chat_state_free ( chatwin - > state ) ;
2016-03-07 13:24:04 -05:00
break ;
2014-12-09 20:44:32 -05:00
}
2016-03-07 13:24:04 -05:00
case WIN_MUC :
{
2014-12-18 18:57:19 -05:00
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
free ( mucwin - > roomjid ) ;
2020-01-23 05:35:33 -05:00
free ( mucwin - > room_name ) ;
2017-01-20 18:26:14 -05:00
free ( mucwin - > enctext ) ;
free ( mucwin - > message_char ) ;
2016-03-07 13:24:04 -05:00
break ;
2014-12-18 18:57:19 -05:00
}
2018-04-11 12:57:50 -04:00
case WIN_CONFIG :
2016-03-07 13:24:04 -05:00
{
2018-04-11 12:57:50 -04:00
ProfConfWin * conf = ( ProfConfWin * ) window ;
free ( conf - > roomjid ) ;
form_destroy ( conf - > form ) ;
2016-03-07 13:24:04 -05:00
break ;
2014-12-09 20:14:11 -05:00
}
2016-03-07 13:24:04 -05:00
case WIN_PRIVATE :
{
2014-12-18 18:57:19 -05:00
ProfPrivateWin * privatewin = ( ProfPrivateWin * ) window ;
free ( privatewin - > fulljid ) ;
2016-03-07 13:24:04 -05:00
break ;
}
case WIN_PLUGIN :
{
ProfPluginWin * pluginwin = ( ProfPluginWin * ) window ;
free ( pluginwin - > tag ) ;
2016-07-12 19:25:45 -04:00
free ( pluginwin - > plugin_name ) ;
2016-03-07 13:24:04 -05:00
break ;
}
default :
break ;
2014-12-18 18:57:19 -05:00
}
2012-11-22 19:19:29 -05:00
free ( window ) ;
}
2013-04-20 18:39:17 -04:00
2015-01-14 19:14:12 -05:00
void
2015-01-31 17:00:22 -05:00
win_page_up ( ProfWin * window )
{
int rows = getmaxy ( stdscr ) ;
int y = getcury ( window - > layout - > win ) ;
int page_space = rows - 4 ;
int * page_start = & ( window - > layout - > y_pos ) ;
* page_start - = page_space ;
// went past beginning, show first page
if ( * page_start < 0 )
* page_start = 0 ;
window - > layout - > paged = 1 ;
win_update_virtual ( window ) ;
// switch off page if last line and space line visible
if ( ( y ) - * page_start = = page_space ) {
window - > layout - > paged = 0 ;
}
}
void
win_page_down ( ProfWin * window )
{
int rows = getmaxy ( stdscr ) ;
int y = getcury ( window - > layout - > win ) ;
int page_space = rows - 4 ;
int * page_start = & ( window - > layout - > y_pos ) ;
* page_start + = page_space ;
// only got half a screen, show full screen
if ( ( y - ( * page_start ) ) < page_space )
* page_start = y - page_space ;
// went past end, show full screen
else if ( * page_start > = y )
* page_start = y - page_space - 1 ;
window - > layout - > paged = 1 ;
win_update_virtual ( window ) ;
// switch off page if last line and space line visible
if ( ( y ) - * page_start = = page_space ) {
window - > layout - > paged = 0 ;
}
}
void
win_sub_page_down ( ProfWin * window )
{
if ( window - > layout - > type = = LAYOUT_SPLIT ) {
int rows = getmaxy ( stdscr ) ;
int page_space = rows - 4 ;
ProfLayoutSplit * split_layout = ( ProfLayoutSplit * ) window - > layout ;
int sub_y = getcury ( split_layout - > subwin ) ;
int * sub_y_pos = & ( split_layout - > sub_y_pos ) ;
* sub_y_pos + = page_space ;
// only got half a screen, show full screen
if ( ( sub_y - ( * sub_y_pos ) ) < page_space )
* sub_y_pos = sub_y - page_space ;
// went past end, show full screen
else if ( * sub_y_pos > = sub_y )
* sub_y_pos = sub_y - page_space - 1 ;
win_update_virtual ( window ) ;
}
}
void
win_sub_page_up ( ProfWin * window )
{
if ( window - > layout - > type = = LAYOUT_SPLIT ) {
int rows = getmaxy ( stdscr ) ;
int page_space = rows - 4 ;
ProfLayoutSplit * split_layout = ( ProfLayoutSplit * ) window - > layout ;
int * sub_y_pos = & ( split_layout - > sub_y_pos ) ;
* sub_y_pos - = page_space ;
// went past beginning, show first page
if ( * sub_y_pos < 0 )
* sub_y_pos = 0 ;
win_update_virtual ( window ) ;
}
}
2015-06-15 12:54:47 -04:00
void
win_clear ( ProfWin * window )
{
2016-11-06 19:26:15 -05:00
if ( ! prefs_get_boolean ( PREF_CLEAR_PERSIST_HISTORY ) ) {
werase ( window - > layout - > win ) ;
2020-02-07 09:52:24 -05:00
buffer_free ( window - > layout - > buffer ) ;
window - > layout - > buffer = buffer_create ( ) ;
2016-11-06 19:26:15 -05:00
return ;
}
2016-10-21 17:03:55 -04:00
int y = getcury ( window - > layout - > win ) ;
int * page_start = & ( window - > layout - > y_pos ) ;
* page_start = y ;
window - > layout - > paged = 1 ;
2015-06-15 12:54:47 -04:00
win_update_virtual ( window ) ;
}
2015-06-15 13:08:47 -04:00
void
win_resize ( ProfWin * window )
{
int cols = getmaxx ( stdscr ) ;
if ( window - > layout - > type = = LAYOUT_SPLIT ) {
ProfLayoutSplit * layout = ( ProfLayoutSplit * ) window - > layout ;
if ( layout - > subwin ) {
2015-10-09 05:20:49 -04:00
int subwin_cols = 0 ;
2015-06-15 13:08:47 -04:00
if ( window - > type = = WIN_CONSOLE ) {
subwin_cols = win_roster_cols ( ) ;
} else if ( window - > type = = WIN_MUC ) {
subwin_cols = win_occpuants_cols ( ) ;
}
2016-01-09 22:11:05 -05:00
wbkgd ( layout - > base . win , theme_attrs ( THEME_TEXT ) ) ;
2015-06-15 13:08:47 -04:00
wresize ( layout - > base . win , PAD_SIZE , cols - subwin_cols ) ;
2016-01-09 22:11:05 -05:00
wbkgd ( layout - > subwin , theme_attrs ( THEME_TEXT ) ) ;
2015-06-15 13:08:47 -04:00
wresize ( layout - > subwin , PAD_SIZE , subwin_cols ) ;
if ( window - > type = = WIN_CONSOLE ) {
rosterwin_roster ( ) ;
} else if ( window - > type = = WIN_MUC ) {
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
occupantswin_occupants ( mucwin - > roomjid ) ;
}
} else {
2016-01-09 22:11:05 -05:00
wbkgd ( layout - > base . win , theme_attrs ( THEME_TEXT ) ) ;
2015-06-15 13:08:47 -04:00
wresize ( layout - > base . win , PAD_SIZE , cols ) ;
}
} else {
2016-01-09 22:11:05 -05:00
wbkgd ( window - > layout - > win , theme_attrs ( THEME_TEXT ) ) ;
2015-06-15 13:08:47 -04:00
wresize ( window - > layout - > win , PAD_SIZE , cols ) ;
}
win_redraw ( window ) ;
}
2013-10-06 12:46:22 -04:00
void
2014-04-01 16:52:04 -04:00
win_update_virtual ( ProfWin * window )
2013-10-05 20:30:53 -04:00
{
2016-09-22 19:56:53 -04:00
int cols = getmaxx ( stdscr ) ;
2014-10-07 11:37:14 -04:00
2016-09-22 19:56:53 -04:00
int row_start = screen_mainwin_row_start ( ) ;
int row_end = screen_mainwin_row_end ( ) ;
2014-12-15 20:39:47 -05:00
if ( window - > layout - > type = = LAYOUT_SPLIT ) {
ProfLayoutSplit * layout = ( ProfLayoutSplit * ) window - > layout ;
if ( layout - > subwin ) {
2015-10-09 05:20:49 -04:00
int subwin_cols = 0 ;
2014-12-15 20:39:47 -05:00
if ( window - > type = = WIN_MUC ) {
subwin_cols = win_occpuants_cols ( ) ;
} else {
subwin_cols = win_roster_cols ( ) ;
}
2016-09-22 19:56:53 -04:00
pnoutrefresh ( layout - > base . win , layout - > base . y_pos , 0 , row_start , 0 , row_end , ( cols - subwin_cols ) - 1 ) ;
pnoutrefresh ( layout - > subwin , layout - > sub_y_pos , 0 , row_start , ( cols - subwin_cols ) , row_end , cols - 1 ) ;
2014-12-09 19:54:46 -05:00
} else {
2016-09-22 19:56:53 -04:00
pnoutrefresh ( layout - > base . win , layout - > base . y_pos , 0 , row_start , 0 , row_end , cols - 1 ) ;
2014-11-15 17:59:13 -05:00
}
2014-12-15 20:39:47 -05:00
} else {
2016-09-22 19:56:53 -04:00
pnoutrefresh ( window - > layout - > win , window - > layout - > y_pos , 0 , row_start , 0 , row_end , cols - 1 ) ;
2014-10-07 11:37:14 -04:00
}
2013-10-05 20:28:25 -04:00
}
2015-06-15 13:59:20 -04:00
void
win_refresh_without_subwin ( ProfWin * window )
{
2016-09-22 19:56:53 -04:00
int cols = getmaxx ( stdscr ) ;
2015-06-15 13:59:20 -04:00
if ( ( window - > type = = WIN_MUC ) | | ( window - > type = = WIN_CONSOLE ) ) {
2016-09-22 19:56:53 -04:00
int row_start = screen_mainwin_row_start ( ) ;
int row_end = screen_mainwin_row_end ( ) ;
pnoutrefresh ( window - > layout - > win , window - > layout - > y_pos , 0 , row_start , 0 , row_end , cols - 1 ) ;
2015-06-15 13:59:20 -04:00
}
}
void
win_refresh_with_subwin ( ProfWin * window )
{
2016-09-22 19:56:53 -04:00
int cols = getmaxx ( stdscr ) ;
2015-06-15 13:59:20 -04:00
int subwin_cols = 0 ;
2016-09-22 19:56:53 -04:00
int row_start = screen_mainwin_row_start ( ) ;
int row_end = screen_mainwin_row_end ( ) ;
2015-06-15 13:59:20 -04:00
if ( window - > type = = WIN_MUC ) {
ProfLayoutSplit * layout = ( ProfLayoutSplit * ) window - > layout ;
subwin_cols = win_occpuants_cols ( ) ;
2016-09-22 19:56:53 -04:00
pnoutrefresh ( layout - > base . win , layout - > base . y_pos , 0 , row_start , 0 , row_end , ( cols - subwin_cols ) - 1 ) ;
pnoutrefresh ( layout - > subwin , layout - > sub_y_pos , 0 , row_start , ( cols - subwin_cols ) , row_end , cols - 1 ) ;
2015-06-15 13:59:20 -04:00
} else if ( window - > type = = WIN_CONSOLE ) {
ProfLayoutSplit * layout = ( ProfLayoutSplit * ) window - > layout ;
subwin_cols = win_roster_cols ( ) ;
2016-09-22 19:56:53 -04:00
pnoutrefresh ( layout - > base . win , layout - > base . y_pos , 0 , row_start , 0 , row_end , ( cols - subwin_cols ) - 1 ) ;
pnoutrefresh ( layout - > subwin , layout - > sub_y_pos , 0 , row_start , ( cols - subwin_cols ) , row_end , cols - 1 ) ;
2015-06-15 13:59:20 -04:00
}
}
2013-10-06 19:59:17 -04:00
void
2014-03-31 16:44:34 -04:00
win_move_to_end ( ProfWin * window )
2013-10-06 19:59:17 -04:00
{
2014-12-15 20:39:47 -05:00
window - > layout - > paged = 0 ;
2013-10-06 19:59:17 -04:00
int rows = getmaxy ( stdscr ) ;
2014-12-15 20:39:47 -05:00
int y = getcury ( window - > layout - > win ) ;
2013-10-06 19:59:17 -04:00
int size = rows - 3 ;
2014-12-15 20:39:47 -05:00
window - > layout - > y_pos = y - ( size - 1 ) ;
if ( window - > layout - > y_pos < 0 ) {
window - > layout - > y_pos = 0 ;
2013-10-06 19:59:17 -04:00
}
}
2014-09-29 19:16:01 -04:00
void
win_show_occupant ( ProfWin * window , Occupant * occupant )
{
const char * presence_str = string_from_resource_presence ( occupant - > presence ) ;
2014-11-16 18:37:07 -05:00
theme_item_t presence_colour = theme_main_presence_attrs ( presence_str ) ;
2014-09-29 19:16:01 -04:00
2016-10-15 13:29:02 -04:00
win_print ( window , presence_colour , ' - ' , " %s " , occupant - > nick ) ;
2016-10-15 14:53:49 -04:00
win_append ( window , presence_colour , " is %s " , presence_str ) ;
2014-09-29 19:16:01 -04:00
if ( occupant - > status ) {
2016-10-15 14:53:49 -04:00
win_append ( window , presence_colour , " , \" %s \" " , occupant - > status ) ;
2014-09-29 19:16:01 -04:00
}
2016-10-15 14:19:44 -04:00
win_appendln ( window , presence_colour , " " ) ;
2014-09-29 19:16:01 -04:00
}
2013-10-06 18:22:46 -04:00
void
win_show_contact ( ProfWin * window , PContact contact )
2013-04-20 20:13:35 -04:00
{
const char * barejid = p_contact_barejid ( contact ) ;
const char * name = p_contact_name ( contact ) ;
const char * presence = p_contact_presence ( contact ) ;
const char * status = p_contact_status ( contact ) ;
GDateTime * last_activity = p_contact_last_activity ( contact ) ;
2014-11-16 18:37:07 -05:00
theme_item_t presence_colour = theme_main_presence_attrs ( presence ) ;
2013-04-20 20:13:35 -04:00
2015-05-04 18:11:32 -04:00
if ( name ) {
2016-10-15 13:29:02 -04:00
win_print ( window , presence_colour , ' - ' , " %s " , name ) ;
2013-05-19 12:00:27 -04:00
} else {
2016-10-15 13:29:02 -04:00
win_print ( window , presence_colour , ' - ' , " %s " , barejid ) ;
2013-04-20 20:13:35 -04:00
}
2016-10-15 14:53:49 -04:00
win_append ( window , presence_colour , " is %s " , presence ) ;
2013-04-20 20:13:35 -04:00
2015-05-04 18:11:32 -04:00
if ( last_activity ) {
2013-04-20 20:13:35 -04:00
GDateTime * now = g_date_time_new_now_local ( ) ;
GTimeSpan span = g_date_time_difference ( now , last_activity ) ;
2016-07-25 18:09:51 -04:00
g_date_time_unref ( now ) ;
2013-04-20 20:13:35 -04:00
int hours = span / G_TIME_SPAN_HOUR ;
span = span - hours * G_TIME_SPAN_HOUR ;
int minutes = span / G_TIME_SPAN_MINUTE ;
span = span - minutes * G_TIME_SPAN_MINUTE ;
int seconds = span / G_TIME_SPAN_SECOND ;
2014-06-21 04:16:50 -04:00
if ( hours > 0 ) {
2016-10-15 14:53:49 -04:00
win_append ( window , presence_colour , " , idle %dh%dm%ds " , hours , minutes , seconds ) ;
} else {
win_append ( window , presence_colour , " , idle %dm%ds " , minutes , seconds ) ;
2014-06-21 04:16:50 -04:00
}
2013-04-20 20:13:35 -04:00
}
2015-05-04 18:11:32 -04:00
if ( status ) {
2016-10-15 14:53:49 -04:00
win_append ( window , presence_colour , " , \" %s \" " , p_contact_status ( contact ) ) ;
2013-04-20 20:13:35 -04:00
}
2016-10-15 14:19:44 -04:00
win_appendln ( window , presence_colour , " " ) ;
2013-04-20 20:13:35 -04:00
}
2013-10-05 20:28:25 -04:00
2014-09-29 19:16:01 -04:00
void
2015-10-25 19:31:11 -04:00
win_show_occupant_info ( ProfWin * window , const char * const room , Occupant * occupant )
2014-09-29 19:16:01 -04:00
{
const char * presence_str = string_from_resource_presence ( occupant - > presence ) ;
2014-09-30 16:58:18 -04:00
const char * occupant_affiliation = muc_occupant_affiliation_str ( occupant ) ;
const char * occupant_role = muc_occupant_role_str ( occupant ) ;
2014-09-29 19:16:01 -04:00
2014-11-16 18:37:07 -05:00
theme_item_t presence_colour = theme_main_presence_attrs ( presence_str ) ;
2014-09-29 19:16:01 -04:00
2016-10-15 13:29:02 -04:00
win_print ( window , presence_colour , ' ! ' , " %s " , occupant - > nick ) ;
2016-10-15 14:53:49 -04:00
win_append ( window , presence_colour , " is %s " , presence_str ) ;
2014-09-29 19:16:01 -04:00
if ( occupant - > status ) {
2016-10-15 14:53:49 -04:00
win_append ( window , presence_colour , " , \" %s \" " , occupant - > status ) ;
2014-09-29 19:16:01 -04:00
}
2015-03-14 10:16:50 -04:00
win_newline ( window ) ;
2014-09-29 19:16:01 -04:00
2014-10-01 08:27:01 -04:00
if ( occupant - > jid ) {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Jid: %s " , occupant - > jid ) ;
2014-10-01 08:27:01 -04:00
}
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Affiliation: %s " , occupant_affiliation ) ;
win_println ( window , THEME_DEFAULT , ' ! ' , " Role: %s " , occupant_role ) ;
2014-09-30 14:46:35 -04:00
2014-09-29 19:16:01 -04:00
Jid * jidp = jid_create_from_bare_and_resource ( room , occupant - > nick ) ;
2016-08-13 11:39:25 -04:00
EntityCapabilities * caps = caps_lookup ( jidp - > fulljid ) ;
2014-10-31 21:48:36 -04:00
jid_destroy ( jidp ) ;
2014-09-29 19:16:01 -04:00
if ( caps ) {
// show identity
2016-08-13 12:19:24 -04:00
if ( caps - > identity ) {
DiscoIdentity * identity = caps - > identity ;
2016-10-15 13:29:02 -04:00
win_print ( window , THEME_DEFAULT , ' ! ' , " Identity: " ) ;
2016-08-13 12:19:24 -04:00
if ( identity - > name ) {
2016-10-15 14:53:49 -04:00
win_append ( window , THEME_DEFAULT , " %s " , identity - > name ) ;
2016-08-13 12:19:24 -04:00
if ( identity - > category | | identity - > type ) {
2016-10-15 14:53:49 -04:00
win_append ( window , THEME_DEFAULT , " " ) ;
2014-09-29 19:16:01 -04:00
}
}
2016-08-13 12:19:24 -04:00
if ( identity - > type ) {
2016-10-15 14:53:49 -04:00
win_append ( window , THEME_DEFAULT , " %s " , identity - > type ) ;
2016-08-13 12:19:24 -04:00
if ( identity - > category ) {
2016-10-15 14:53:49 -04:00
win_append ( window , THEME_DEFAULT , " " ) ;
2014-09-29 19:16:01 -04:00
}
}
2016-08-13 12:19:24 -04:00
if ( identity - > category ) {
2016-10-15 14:53:49 -04:00
win_append ( window , THEME_DEFAULT , " %s " , identity - > category ) ;
2014-09-29 19:16:01 -04:00
}
2015-03-14 10:16:50 -04:00
win_newline ( window ) ;
2014-09-29 19:16:01 -04:00
}
2016-08-13 12:19:24 -04:00
2015-05-04 18:11:32 -04:00
if ( caps - > software_version ) {
2016-08-13 12:43:43 -04:00
SoftwareVersion * software_version = caps - > software_version ;
if ( software_version - > software ) {
2016-10-15 14:19:44 -04:00
win_print ( window , THEME_DEFAULT , ' ! ' , " Software: %s " , software_version - > software ) ;
2016-08-13 12:43:43 -04:00
}
if ( software_version - > software_version ) {
2016-10-15 14:53:49 -04:00
win_append ( window , THEME_DEFAULT , " , %s " , software_version - > software_version ) ;
2016-08-13 12:43:43 -04:00
}
if ( software_version - > software | | software_version - > software_version ) {
win_newline ( window ) ;
}
if ( software_version - > os ) {
2016-10-15 14:19:44 -04:00
win_print ( window , THEME_DEFAULT , ' ! ' , " OS: %s " , software_version - > os ) ;
2016-08-13 12:43:43 -04:00
}
if ( software_version - > os_version ) {
2016-10-15 14:53:49 -04:00
win_append ( window , THEME_DEFAULT , " , %s " , software_version - > os_version ) ;
2016-08-13 12:43:43 -04:00
}
if ( software_version - > os | | software_version - > os_version ) {
win_newline ( window ) ;
}
2014-09-29 19:16:01 -04:00
}
2016-08-13 12:43:43 -04:00
2014-09-29 19:16:01 -04:00
caps_destroy ( caps ) ;
}
2014-09-30 16:58:18 -04:00
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " " ) ;
2014-09-29 19:16:01 -04:00
}
2014-06-03 16:14:21 -04:00
void
win_show_info ( ProfWin * window , PContact contact )
{
const char * barejid = p_contact_barejid ( contact ) ;
const char * name = p_contact_name ( contact ) ;
const char * presence = p_contact_presence ( contact ) ;
const char * sub = p_contact_subscription ( contact ) ;
GDateTime * last_activity = p_contact_last_activity ( contact ) ;
2014-11-16 18:37:07 -05:00
theme_item_t presence_colour = theme_main_presence_attrs ( presence ) ;
2014-06-21 04:16:50 -04:00
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " " ) ;
2016-10-15 14:19:44 -04:00
win_print ( window , presence_colour , ' - ' , " %s " , barejid ) ;
2015-05-04 18:11:32 -04:00
if ( name ) {
2016-10-15 14:53:49 -04:00
win_append ( window , presence_colour , " (%s) " , name ) ;
2014-06-03 16:14:21 -04:00
}
2016-10-15 14:19:44 -04:00
win_appendln ( window , THEME_DEFAULT , " : " ) ;
2014-06-03 16:14:21 -04:00
2015-05-04 18:11:32 -04:00
if ( sub ) {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Subscription: %s " , sub ) ;
2014-06-03 16:14:21 -04:00
}
2015-05-04 18:11:32 -04:00
if ( last_activity ) {
2014-06-03 16:14:21 -04:00
GDateTime * now = g_date_time_new_now_local ( ) ;
GTimeSpan span = g_date_time_difference ( now , last_activity ) ;
int hours = span / G_TIME_SPAN_HOUR ;
span = span - hours * G_TIME_SPAN_HOUR ;
int minutes = span / G_TIME_SPAN_MINUTE ;
span = span - minutes * G_TIME_SPAN_MINUTE ;
int seconds = span / G_TIME_SPAN_SECOND ;
2014-06-21 04:16:50 -04:00
if ( hours > 0 ) {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Last activity: %dh%dm%ds " , hours , minutes , seconds ) ;
2014-06-21 04:16:50 -04:00
}
else {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Last activity: %dm%ds " , minutes , seconds ) ;
2014-06-21 04:16:50 -04:00
}
2014-06-03 16:14:21 -04:00
g_date_time_unref ( now ) ;
}
2015-02-09 16:46:54 -05:00
GList * resources = p_contact_get_available_resources ( contact ) ;
GList * ordered_resources = NULL ;
2015-05-04 18:11:32 -04:00
if ( resources ) {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Resources: " ) ;
2014-06-03 16:14:21 -04:00
2015-02-17 04:52:37 -05:00
// sort in order of availability
2015-02-09 16:46:54 -05:00
GList * curr = resources ;
2015-05-04 18:11:32 -04:00
while ( curr ) {
2015-02-09 16:46:54 -05:00
Resource * resource = curr - > data ;
2014-06-03 16:14:21 -04:00
ordered_resources = g_list_insert_sorted ( ordered_resources ,
resource , ( GCompareFunc ) resource_compare_availability ) ;
2015-02-09 16:46:54 -05:00
curr = g_list_next ( curr ) ;
2014-06-03 16:14:21 -04:00
}
}
2015-02-09 16:46:54 -05:00
g_list_free ( resources ) ;
2014-06-03 16:14:21 -04:00
2015-02-09 16:46:54 -05:00
GList * curr = ordered_resources ;
2015-05-04 18:11:32 -04:00
while ( curr ) {
2015-02-09 16:46:54 -05:00
Resource * resource = curr - > data ;
2014-06-03 16:14:21 -04:00
const char * resource_presence = string_from_resource_presence ( resource - > presence ) ;
2014-11-16 18:37:07 -05:00
theme_item_t presence_colour = theme_main_presence_attrs ( resource_presence ) ;
2016-10-15 14:19:44 -04:00
win_print ( window , presence_colour , ' - ' , " %s (%d), %s " , resource - > name , resource - > priority , resource_presence ) ;
2015-05-04 18:11:32 -04:00
if ( resource - > status ) {
2016-10-15 14:53:49 -04:00
win_append ( window , presence_colour , " , \" %s \" " , resource - > status ) ;
2014-06-03 16:14:21 -04:00
}
2015-03-14 10:16:50 -04:00
win_newline ( window ) ;
2014-06-03 16:14:21 -04:00
2014-09-20 18:50:19 -04:00
Jid * jidp = jid_create_from_bare_and_resource ( barejid , resource - > name ) ;
2016-08-13 11:39:25 -04:00
EntityCapabilities * caps = caps_lookup ( jidp - > fulljid ) ;
2014-10-31 21:48:36 -04:00
jid_destroy ( jidp ) ;
2014-09-20 18:50:19 -04:00
if ( caps ) {
// show identity
2016-08-13 12:19:24 -04:00
if ( caps - > identity ) {
DiscoIdentity * identity = caps - > identity ;
2016-10-15 14:19:44 -04:00
win_print ( window , THEME_DEFAULT , ' - ' , " Identity: " ) ;
2016-08-13 12:19:24 -04:00
if ( identity - > name ) {
2016-10-15 14:53:49 -04:00
win_append ( window , THEME_DEFAULT , " %s " , identity - > name ) ;
2016-08-13 12:19:24 -04:00
if ( identity - > category | | identity - > type ) {
2016-10-15 14:53:49 -04:00
win_append ( window , THEME_DEFAULT , " " ) ;
2014-06-03 16:14:21 -04:00
}
2014-09-20 18:50:19 -04:00
}
2016-08-13 12:19:24 -04:00
if ( identity - > type ) {
2016-10-15 14:53:49 -04:00
win_append ( window , THEME_DEFAULT , " %s " , identity - > type ) ;
2016-08-13 12:19:24 -04:00
if ( identity - > category ) {
2016-10-15 14:53:49 -04:00
win_append ( window , THEME_DEFAULT , " " ) ;
2014-06-03 16:14:21 -04:00
}
}
2016-08-13 12:19:24 -04:00
if ( identity - > category ) {
2016-10-15 14:53:49 -04:00
win_append ( window , THEME_DEFAULT , " %s " , identity - > category ) ;
2014-06-03 16:14:21 -04:00
}
2015-03-14 10:16:50 -04:00
win_newline ( window ) ;
2014-09-20 18:50:19 -04:00
}
2016-08-13 12:19:24 -04:00
2015-05-04 18:11:32 -04:00
if ( caps - > software_version ) {
2016-08-13 12:43:43 -04:00
SoftwareVersion * software_version = caps - > software_version ;
if ( software_version - > software ) {
2016-10-15 14:19:44 -04:00
win_print ( window , THEME_DEFAULT , ' - ' , " Software: %s " , software_version - > software ) ;
2016-08-13 12:43:43 -04:00
}
if ( software_version - > software_version ) {
2016-10-15 14:53:49 -04:00
win_append ( window , THEME_DEFAULT , " , %s " , software_version - > software_version ) ;
2016-08-13 12:43:43 -04:00
}
if ( software_version - > software | | software_version - > software_version ) {
win_newline ( window ) ;
}
if ( software_version - > os ) {
2016-10-15 14:19:44 -04:00
win_print ( window , THEME_DEFAULT , ' - ' , " OS: %s " , software_version - > os ) ;
2016-08-13 12:43:43 -04:00
}
if ( software_version - > os_version ) {
2016-10-15 14:53:49 -04:00
win_append ( window , THEME_DEFAULT , " , %s " , software_version - > os_version ) ;
2016-08-13 12:43:43 -04:00
}
if ( software_version - > os | | software_version - > os_version ) {
win_newline ( window ) ;
}
2014-06-03 16:14:21 -04:00
}
2016-08-13 12:43:43 -04:00
2014-09-21 20:36:45 -04:00
caps_destroy ( caps ) ;
2014-06-03 16:14:21 -04:00
}
2015-02-09 16:46:54 -05:00
curr = g_list_next ( curr ) ;
2014-06-03 16:14:21 -04:00
}
2015-02-09 16:46:54 -05:00
g_list_free ( ordered_resources ) ;
2014-06-03 16:14:21 -04:00
}
2013-10-06 18:52:50 -04:00
void
2015-10-25 19:31:11 -04:00
win_show_status_string ( ProfWin * window , const char * const from ,
const char * const show , const char * const status ,
GDateTime * last_activity , const char * const pre ,
const char * const default_show )
2013-10-06 18:52:50 -04:00
{
2014-11-16 15:40:19 -05:00
theme_item_t presence_colour ;
2013-10-06 18:52:50 -04:00
2015-05-04 18:11:32 -04:00
if ( show ) {
2014-11-16 18:37:07 -05:00
presence_colour = theme_main_presence_attrs ( show ) ;
2013-10-06 18:52:50 -04:00
} else if ( strcmp ( default_show , " online " ) = = 0 ) {
2014-11-16 15:40:19 -05:00
presence_colour = THEME_ONLINE ;
2013-10-06 18:52:50 -04:00
} else {
2014-11-16 15:40:19 -05:00
presence_colour = THEME_OFFLINE ;
2013-10-06 18:52:50 -04:00
}
2016-10-15 14:19:44 -04:00
win_print ( window , presence_colour , ' - ' , " %s %s " , pre , from ) ;
2013-10-06 18:52:50 -04:00
2015-05-04 18:11:32 -04:00
if ( show )
2016-10-15 14:53:49 -04:00
win_append ( window , presence_colour , " is %s " , show ) ;
2013-10-06 18:52:50 -04:00
else
2016-10-15 14:53:49 -04:00
win_append ( window , presence_colour , " is %s " , default_show ) ;
2013-10-06 18:52:50 -04:00
2015-05-04 18:11:32 -04:00
if ( last_activity ) {
2015-09-29 18:30:23 -04:00
gchar * date_fmt = NULL ;
char * time_pref = prefs_get_string ( PREF_TIME_LASTACTIVITY ) ;
date_fmt = g_date_time_format ( last_activity , time_pref ) ;
prefs_free_string ( time_pref ) ;
assert ( date_fmt ! = NULL ) ;
2013-10-06 18:52:50 -04:00
2016-10-15 14:53:49 -04:00
win_append ( window , presence_colour , " , last activity: %s " , date_fmt ) ;
2014-06-21 04:16:50 -04:00
2015-09-29 18:30:23 -04:00
g_free ( date_fmt ) ;
2013-10-06 18:52:50 -04:00
}
2015-05-04 18:11:32 -04:00
if ( status )
2016-10-15 14:53:49 -04:00
win_append ( window , presence_colour , " , \" %s \" " , status ) ;
2013-10-06 18:52:50 -04:00
2016-10-15 14:19:44 -04:00
win_appendln ( window , presence_colour , " " ) ;
2013-10-06 18:52:50 -04:00
}
2020-02-12 01:07:54 -05:00
static void
_win_correct ( ProfWin * window , const char * const message , const char * const id , const char * const replace_id )
2020-02-10 07:19:54 -05:00
{
ProfBuffEntry * entry = buffer_get_entry_by_id ( window - > layout - > buffer , replace_id ) ;
if ( ! entry ) {
log_debug ( " Replace ID %s could not be found in buffer. Message: %s " , replace_id , message ) ;
return ;
}
2020-02-10 08:52:42 -05:00
/*TODO: set date?
2020-02-10 07:19:54 -05:00
if ( entry - > date ) {
if ( entry - > date - > timestamp ) {
g_date_time_unref ( entry - > date - > timestamp ) ;
}
free ( entry - > date ) ;
}
entry - > date = buffer_date_new_now ( ) ;
*/
2020-02-10 08:52:42 -05:00
entry - > show_char = prefs_get_correction_char ( ) ;
2020-02-10 07:19:54 -05:00
if ( entry - > message ) {
free ( entry - > message ) ;
}
entry - > message = strdup ( message ) ;
if ( entry - > id ) {
free ( entry - > id ) ;
}
entry - > id = strdup ( id ) ;
win_redraw ( window ) ;
}
2014-01-08 15:11:53 -05:00
void
2020-02-13 09:55:10 -05:00
win_print_incoming ( ProfWin * window , const char * const display_name_from , ProfMessage * message )
2014-01-08 15:11:53 -05:00
{
2015-08-25 19:42:56 -04:00
char enc_char = ' - ' ;
2019-06-16 16:55:07 -04:00
int flags = NO_ME ;
2019-06-17 00:23:40 -04:00
if ( ! message - > trusted ) {
2019-06-18 00:23:06 -04:00
flags | = UNTRUSTED ;
2019-06-16 16:55:07 -04:00
}
2015-08-25 19:42:56 -04:00
2014-01-08 15:11:53 -05:00
switch ( window - > type )
{
case WIN_CHAT :
2017-01-20 16:03:55 -05:00
{
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
if ( chatwin - > incoming_char ) {
enc_char = chatwin - > incoming_char [ 0 ] ;
2019-06-17 00:23:40 -04:00
} else if ( message - > enc = = PROF_MSG_ENC_OTR ) {
2015-08-25 20:06:10 -04:00
enc_char = prefs_get_otr_char ( ) ;
2019-06-17 00:23:40 -04:00
} else if ( message - > enc = = PROF_MSG_ENC_PGP ) {
2015-08-25 20:06:10 -04:00
enc_char = prefs_get_pgp_char ( ) ;
2019-06-17 00:23:40 -04:00
} else if ( message - > enc = = PROF_MSG_ENC_OMEMO ) {
2019-02-26 13:53:06 -05:00
enc_char = prefs_get_omemo_char ( ) ;
2015-08-25 19:42:56 -04:00
}
2020-02-10 07:19:54 -05:00
2020-02-12 11:42:43 -05:00
if ( prefs_get_boolean ( PREF_CORRECTION_ALLOW ) & & message - > replace_id ) {
2020-02-12 01:07:54 -05:00
_win_correct ( window , message - > plain , message - > id , message - > replace_id ) ;
2020-02-10 07:19:54 -05:00
} else {
2020-02-13 09:55:10 -05:00
_win_printf ( window , enc_char , 0 , message - > timestamp , flags , THEME_TEXT_THEM , display_name_from , message - > id , " %s " , message - > plain ) ;
2020-02-10 07:19:54 -05:00
}
2015-08-25 19:42:56 -04:00
break ;
2017-01-20 16:03:55 -05:00
}
2014-01-08 15:11:53 -05:00
case WIN_PRIVATE :
2020-02-13 09:55:10 -05:00
_win_printf ( window , ' - ' , 0 , message - > timestamp , flags , THEME_TEXT_THEM , display_name_from , message - > id , " %s " , message - > plain ) ;
2014-01-08 15:11:53 -05:00
break ;
2014-01-08 15:27:18 -05:00
default :
assert ( FALSE ) ;
break ;
}
}
2016-10-15 15:07:33 -04:00
void
2019-06-17 00:23:40 -04:00
win_print_them ( ProfWin * window , theme_item_t theme_item , char ch , int flags , const char * const them )
2016-10-15 17:12:07 -04:00
{
2020-02-10 07:19:54 -05:00
_win_printf ( window , ch , 0 , NULL , flags | NO_ME | NO_EOL , theme_item , them , NULL , " " ) ;
2016-10-15 17:12:07 -04:00
}
void
2020-02-17 05:58:36 -05:00
win_println_incoming_muc_msg ( ProfWin * window , char ch , int flags , const char * const them , const char * const id , const char * const replace_id , const char * const message )
2016-10-15 15:07:33 -04:00
{
2020-02-12 06:56:34 -05:00
//TODO: we always use current timestamp here. instead of the message->timestamp one if available. i think somewhere else we check whether it exists first.
2016-10-15 15:07:33 -04:00
GDateTime * timestamp = g_date_time_new_now_local ( ) ;
2020-02-12 11:42:43 -05:00
if ( prefs_get_boolean ( PREF_CORRECTION_ALLOW ) & & replace_id ) {
2020-02-17 05:58:36 -05:00
_win_correct ( window , message , id , replace_id ) ;
2020-02-12 06:56:34 -05:00
} else {
2020-02-17 05:58:36 -05:00
_win_printf ( window , ch , 0 , timestamp , flags | NO_ME , THEME_TEXT_THEM , them , id , " %s " , message ) ;
2020-02-12 06:56:34 -05:00
}
2020-02-17 05:58:36 -05:00
// buffer_append(window->layout->buffer, ch, 0, timestamp, flags | NO_ME, THEME_TEXT_THEM, them, message, NULL, NULL);
// _win_print_internal(window, ch, 0, timestamp, flags | NO_ME, THEME_TEXT_THEM, them, message, NULL);
2016-10-15 15:07:33 -04:00
inp_nonblocking ( TRUE ) ;
g_date_time_unref ( timestamp ) ;
}
2016-10-15 15:55:45 -04:00
void
2020-02-17 06:03:23 -05:00
win_print_outgoing_muc_msg ( ProfWin * window , char ch , const char * const me , const char * const id , const char * const replace_id , const char * const message )
2016-10-15 15:55:45 -04:00
{
2016-10-15 17:12:07 -04:00
GDateTime * timestamp = g_date_time_new_now_local ( ) ;
2016-10-15 15:55:45 -04:00
2020-02-12 11:42:43 -05:00
if ( prefs_get_boolean ( PREF_CORRECTION_ALLOW ) & & replace_id ) {
2020-02-17 06:03:23 -05:00
_win_correct ( window , message , id , replace_id ) ;
2020-02-12 08:06:00 -05:00
} else {
2020-02-17 06:03:23 -05:00
_win_printf ( window , ch , 0 , timestamp , 0 , THEME_TEXT_ME , me , id , " %s " , message ) ;
2020-02-12 08:06:00 -05:00
}
2020-02-17 06:03:23 -05:00
// buffer_append(window->layout->buffer, ch, 0, timestamp, 0, THEME_TEXT_ME, me, message, NULL, NULL);
// _win_print_internal(window, ch, 0, timestamp, 0, THEME_TEXT_ME, me, message, NULL);
2016-10-15 15:55:45 -04:00
inp_nonblocking ( TRUE ) ;
g_date_time_unref ( timestamp ) ;
}
2014-07-16 17:03:46 -04:00
void
2020-02-17 05:48:50 -05:00
win_print_outgoing ( ProfWin * window , const char ch , const char * const id , const char * const replace_id , const char * const message )
2014-07-16 17:03:46 -04:00
{
2020-02-17 05:48:50 -05:00
//TODO: we always use current timestamp here. instead of the message->timestamp one if available. i think somewhere else we check whether it exists first.
2016-10-15 17:12:07 -04:00
GDateTime * timestamp = g_date_time_new_now_local ( ) ;
2014-07-16 17:03:46 -04:00
2020-02-11 09:26:58 -05:00
if ( replace_id ) {
2020-02-17 05:48:50 -05:00
_win_correct ( window , message , id , replace_id ) ;
2020-02-11 09:26:58 -05:00
} else {
2020-02-17 05:48:50 -05:00
_win_printf ( window , ch , 0 , timestamp , 0 , THEME_TEXT_THEM , " me " , id , " %s " , message ) ;
2020-02-11 09:26:58 -05:00
}
2016-10-11 18:38:59 -04:00
2016-10-15 17:12:07 -04:00
inp_nonblocking ( TRUE ) ;
g_date_time_unref ( timestamp ) ;
}
void
2020-02-17 06:05:58 -05:00
win_print_history ( ProfWin * window , GDateTime * timestamp , const char * const message )
2016-10-15 17:12:07 -04:00
{
g_date_time_ref ( timestamp ) ;
2020-02-17 06:05:58 -05:00
buffer_append ( window - > layout - > buffer , ' - ' , 0 , timestamp , 0 , THEME_TEXT_HISTORY , " " , message , NULL , NULL ) ;
_win_print_internal ( window , ' - ' , 0 , timestamp , 0 , THEME_TEXT_HISTORY , " " , message , NULL ) ;
2016-10-15 17:12:07 -04:00
2016-10-11 19:14:55 -04:00
inp_nonblocking ( TRUE ) ;
g_date_time_unref ( timestamp ) ;
}
void
2016-10-15 13:29:02 -04:00
win_print ( ProfWin * window , theme_item_t theme_item , const char ch , const char * const message , . . . )
{
GDateTime * timestamp = g_date_time_new_now_local ( ) ;
va_list arg ;
va_start ( arg , message ) ;
GString * fmt_msg = g_string_new ( NULL ) ;
g_string_vprintf ( fmt_msg , message , arg ) ;
2019-11-01 12:53:59 -04:00
buffer_append ( window - > layout - > buffer , ch , 0 , timestamp , NO_EOL , theme_item , " " , fmt_msg - > str , NULL , NULL ) ;
2020-02-12 02:32:34 -05:00
_win_print_internal ( window , ch , 0 , timestamp , NO_EOL , theme_item , " " , fmt_msg - > str , NULL ) ;
2016-10-15 13:29:02 -04:00
inp_nonblocking ( TRUE ) ;
g_date_time_unref ( timestamp ) ;
g_string_free ( fmt_msg , TRUE ) ;
va_end ( arg ) ;
}
void
win_println ( ProfWin * window , theme_item_t theme_item , const char ch , const char * const message , . . . )
2016-10-11 19:14:55 -04:00
{
GDateTime * timestamp = g_date_time_new_now_local ( ) ;
va_list arg ;
va_start ( arg , message ) ;
GString * fmt_msg = g_string_new ( NULL ) ;
g_string_vprintf ( fmt_msg , message , arg ) ;
2019-11-01 12:53:59 -04:00
buffer_append ( window - > layout - > buffer , ch , 0 , timestamp , 0 , theme_item , " " , fmt_msg - > str , NULL , NULL ) ;
2020-02-12 02:32:34 -05:00
_win_print_internal ( window , ch , 0 , timestamp , 0 , theme_item , " " , fmt_msg - > str , NULL ) ;
2016-10-11 19:14:55 -04:00
2015-11-01 13:56:34 -05:00
inp_nonblocking ( TRUE ) ;
2015-08-08 19:40:37 -04:00
g_date_time_unref ( timestamp ) ;
2016-10-11 18:38:59 -04:00
g_string_free ( fmt_msg , TRUE ) ;
va_end ( arg ) ;
2014-06-29 09:04:23 -04:00
}
2016-10-15 16:05:26 -04:00
void
win_println_indent ( ProfWin * window , int pad , const char * const message , . . . )
{
GDateTime * timestamp = g_date_time_new_now_local ( ) ;
va_list arg ;
va_start ( arg , message ) ;
GString * fmt_msg = g_string_new ( NULL ) ;
g_string_vprintf ( fmt_msg , message , arg ) ;
2019-11-01 12:53:59 -04:00
buffer_append ( window - > layout - > buffer , ' - ' , pad , timestamp , 0 , THEME_DEFAULT , " " , fmt_msg - > str , NULL , NULL ) ;
2020-02-12 02:32:34 -05:00
_win_print_internal ( window , ' - ' , pad , timestamp , 0 , THEME_DEFAULT , " " , fmt_msg - > str , NULL ) ;
2016-10-15 16:05:26 -04:00
inp_nonblocking ( TRUE ) ;
g_date_time_unref ( timestamp ) ;
g_string_free ( fmt_msg , TRUE ) ;
va_end ( arg ) ;
}
2016-10-15 14:53:49 -04:00
void
win_append ( ProfWin * window , theme_item_t theme_item , const char * const message , . . . )
{
GDateTime * timestamp = g_date_time_new_now_local ( ) ;
va_list arg ;
va_start ( arg , message ) ;
GString * fmt_msg = g_string_new ( NULL ) ;
g_string_vprintf ( fmt_msg , message , arg ) ;
2019-11-01 12:53:59 -04:00
buffer_append ( window - > layout - > buffer , ' - ' , 0 , timestamp , NO_DATE | NO_EOL , theme_item , " " , fmt_msg - > str , NULL , NULL ) ;
2020-02-12 02:32:34 -05:00
_win_print_internal ( window , ' - ' , 0 , timestamp , NO_DATE | NO_EOL , theme_item , " " , fmt_msg - > str , NULL ) ;
2016-10-15 14:53:49 -04:00
inp_nonblocking ( TRUE ) ;
g_date_time_unref ( timestamp ) ;
g_string_free ( fmt_msg , TRUE ) ;
va_end ( arg ) ;
}
2016-10-15 14:19:44 -04:00
void
win_appendln ( ProfWin * window , theme_item_t theme_item , const char * const message , . . . )
{
GDateTime * timestamp = g_date_time_new_now_local ( ) ;
va_list arg ;
va_start ( arg , message ) ;
GString * fmt_msg = g_string_new ( NULL ) ;
g_string_vprintf ( fmt_msg , message , arg ) ;
2019-11-01 12:53:59 -04:00
buffer_append ( window - > layout - > buffer , ' - ' , 0 , timestamp , NO_DATE , theme_item , " " , fmt_msg - > str , NULL , NULL ) ;
2020-02-12 02:32:34 -05:00
_win_print_internal ( window , ' - ' , 0 , timestamp , NO_DATE , theme_item , " " , fmt_msg - > str , NULL ) ;
2016-10-15 14:19:44 -04:00
inp_nonblocking ( TRUE ) ;
g_date_time_unref ( timestamp ) ;
g_string_free ( fmt_msg , TRUE ) ;
va_end ( arg ) ;
}
2016-10-15 14:53:49 -04:00
2016-10-15 17:12:07 -04:00
void
win_append_highlight ( ProfWin * window , theme_item_t theme_item , const char * const message , . . . )
{
GDateTime * timestamp = g_date_time_new_now_local ( ) ;
va_list arg ;
va_start ( arg , message ) ;
GString * fmt_msg = g_string_new ( NULL ) ;
g_string_vprintf ( fmt_msg , message , arg ) ;
2019-11-01 12:53:59 -04:00
buffer_append ( window - > layout - > buffer , ' - ' , 0 , timestamp , NO_DATE | NO_ME | NO_EOL , theme_item , " " , fmt_msg - > str , NULL , NULL ) ;
2020-02-12 02:32:34 -05:00
_win_print_internal ( window , ' - ' , 0 , timestamp , NO_DATE | NO_ME | NO_EOL , theme_item , " " , fmt_msg - > str , NULL ) ;
2016-10-15 17:12:07 -04:00
inp_nonblocking ( TRUE ) ;
g_date_time_unref ( timestamp ) ;
g_string_free ( fmt_msg , TRUE ) ;
va_end ( arg ) ;
}
void
win_appendln_highlight ( ProfWin * window , theme_item_t theme_item , const char * const message , . . . )
{
GDateTime * timestamp = g_date_time_new_now_local ( ) ;
va_list arg ;
va_start ( arg , message ) ;
GString * fmt_msg = g_string_new ( NULL ) ;
g_string_vprintf ( fmt_msg , message , arg ) ;
2019-11-01 12:53:59 -04:00
buffer_append ( window - > layout - > buffer , ' - ' , 0 , timestamp , NO_DATE | NO_ME , theme_item , " " , fmt_msg - > str , NULL , NULL ) ;
2020-02-12 02:32:34 -05:00
_win_print_internal ( window , ' - ' , 0 , timestamp , NO_DATE | NO_ME , theme_item , " " , fmt_msg - > str , NULL ) ;
2016-10-15 17:12:07 -04:00
inp_nonblocking ( TRUE ) ;
g_date_time_unref ( timestamp ) ;
g_string_free ( fmt_msg , TRUE ) ;
va_end ( arg ) ;
}
2016-10-11 18:40:15 -04:00
void
win_print_http_upload ( ProfWin * window , const char * const message , char * url )
{
2020-02-13 06:24:12 -05:00
win_print_outgoing_with_receipt ( window , ' ! ' , NULL , message , url , NULL ) ;
2016-10-11 18:40:15 -04:00
}
2015-03-14 12:05:13 -04:00
void
2020-02-13 06:24:12 -05:00
win_print_outgoing_with_receipt ( ProfWin * window , const char show_char , const char * const from , const char * const message , char * id , const char * const replace_id )
2015-03-14 12:05:13 -04:00
{
2016-10-11 18:47:13 -04:00
GDateTime * time = g_date_time_new_now_local ( ) ;
2015-03-14 12:05:13 -04:00
DeliveryReceipt * receipt = malloc ( sizeof ( struct delivery_receipt_t ) ) ;
receipt - > received = FALSE ;
2020-02-13 06:24:12 -05:00
if ( replace_id ) {
_win_correct ( window , message , id , replace_id ) ;
} else {
buffer_append ( window - > layout - > buffer , show_char , 0 , time , 0 , THEME_TEXT_ME , from , message , receipt , id ) ;
_win_print_internal ( window , show_char , 0 , time , 0 , THEME_TEXT_ME , from , message , receipt ) ;
}
2020-02-12 02:32:34 -05:00
2015-03-14 12:05:13 -04:00
// TODO: cross-reference.. this should be replaced by a real event-based system
2015-11-01 13:56:34 -05:00
inp_nonblocking ( TRUE ) ;
2015-08-09 18:08:36 -04:00
g_date_time_unref ( time ) ;
2015-03-14 12:05:13 -04:00
}
void
2015-10-25 19:31:11 -04:00
win_mark_received ( ProfWin * window , const char * const id )
2015-03-14 12:05:13 -04:00
{
gboolean received = buffer_mark_received ( window - > layout - > buffer , id ) ;
if ( received ) {
win_redraw ( window ) ;
}
}
2016-04-11 14:13:18 -04:00
void
win_update_entry_message ( ProfWin * window , const char * const id , const char * const message )
{
2016-10-16 14:40:43 -04:00
ProfBuffEntry * entry = buffer_get_entry_by_id ( window - > layout - > buffer , id ) ;
2016-04-11 14:13:18 -04:00
if ( entry ) {
free ( entry - > message ) ;
entry - > message = strdup ( message ) ;
win_redraw ( window ) ;
}
}
2019-12-13 06:05:24 -05:00
void
win_remove_entry_message ( ProfWin * window , const char * const id )
{
buffer_remove_entry_by_id ( window - > layout - > buffer , id ) ;
win_redraw ( window ) ;
}
2014-07-20 18:57:31 -04:00
void
2015-03-14 10:16:50 -04:00
win_newline ( ProfWin * window )
2014-07-20 18:57:31 -04:00
{
2016-10-15 14:19:44 -04:00
win_appendln ( window , THEME_DEFAULT , " " ) ;
2014-07-20 18:57:31 -04:00
}
2016-10-15 17:12:07 -04:00
static void
_win_printf ( ProfWin * window , const char show_char , int pad_indent , GDateTime * timestamp ,
2020-02-10 07:19:54 -05:00
int flags , theme_item_t theme_item , const char * const from , const char * const message_id , const char * const message , . . . )
2016-10-15 17:12:07 -04:00
{
if ( timestamp = = NULL ) {
timestamp = g_date_time_new_now_local ( ) ;
} else {
g_date_time_ref ( timestamp ) ;
}
va_list arg ;
va_start ( arg , message ) ;
GString * fmt_msg = g_string_new ( NULL ) ;
g_string_vprintf ( fmt_msg , message , arg ) ;
2020-02-10 07:19:54 -05:00
buffer_append ( window - > layout - > buffer , show_char , pad_indent , timestamp , flags , theme_item , from , fmt_msg - > str , NULL , message_id ) ;
2016-10-15 17:12:07 -04:00
2020-02-12 02:32:34 -05:00
_win_print_internal ( window , show_char , pad_indent , timestamp , flags , theme_item , from , fmt_msg - > str , NULL ) ;
2016-10-15 17:12:07 -04:00
inp_nonblocking ( TRUE ) ;
g_date_time_unref ( timestamp ) ;
g_string_free ( fmt_msg , TRUE ) ;
va_end ( arg ) ;
}
2014-07-20 18:35:48 -04:00
static void
2020-02-12 02:32:34 -05:00
_win_print_internal ( ProfWin * window , const char show_char , int pad_indent , GDateTime * time ,
2015-10-25 19:31:11 -04:00
int flags , theme_item_t theme_item , const char * const from , const char * const message , DeliveryReceipt * receipt )
2014-07-16 17:03:46 -04:00
{
2014-06-29 09:04:23 -04:00
// flags : 1st bit = 0/1 - me/not me
// 2nd bit = 0/1 - date/no date
// 3rd bit = 0/1 - eol/no eol
// 4th bit = 0/1 - color from/no color from
2014-11-15 20:11:00 -05:00
// 5th bit = 0/1 - color date/no date
2019-06-18 00:23:06 -04:00
// 6th bit = 0/1 - trusted/untrusted
2014-11-30 17:50:02 -05:00
gboolean me_message = FALSE ;
2014-06-29 09:04:23 -04:00
int offset = 0 ;
2014-11-16 15:40:19 -05:00
int colour = theme_attrs ( THEME_ME ) ;
2015-05-29 21:45:10 -04:00
size_t indent = 0 ;
2014-07-16 17:03:46 -04:00
2015-09-30 17:34:27 -04:00
char * time_pref = NULL ;
switch ( window - > type ) {
case WIN_CHAT :
time_pref = prefs_get_string ( PREF_TIME_CHAT ) ;
break ;
case WIN_MUC :
time_pref = prefs_get_string ( PREF_TIME_MUC ) ;
break ;
2018-04-11 12:57:50 -04:00
case WIN_CONFIG :
time_pref = prefs_get_string ( PREF_TIME_CONFIG ) ;
2015-09-30 17:34:27 -04:00
break ;
case WIN_PRIVATE :
time_pref = prefs_get_string ( PREF_TIME_PRIVATE ) ;
break ;
case WIN_XML :
time_pref = prefs_get_string ( PREF_TIME_XMLCONSOLE ) ;
break ;
default :
time_pref = prefs_get_string ( PREF_TIME_CONSOLE ) ;
break ;
}
2015-07-01 15:16:09 -04:00
gchar * date_fmt = NULL ;
2019-12-01 12:01:28 -05:00
if ( g_strcmp0 ( time_pref , " off " ) = = 0 | | time = = NULL ) {
2015-09-30 17:34:27 -04:00
date_fmt = g_strdup ( " " ) ;
} else {
date_fmt = g_date_time_format ( time , time_pref ) ;
}
2015-08-08 19:40:37 -04:00
prefs_free_string ( time_pref ) ;
2015-07-01 15:16:09 -04:00
assert ( date_fmt ! = NULL ) ;
2014-11-15 20:11:00 -05:00
2015-07-01 15:16:09 -04:00
if ( strlen ( date_fmt ) ! = 0 ) {
indent = 3 + strlen ( date_fmt ) ;
}
2014-11-15 20:11:00 -05:00
2015-07-01 15:16:09 -04:00
if ( ( flags & NO_DATE ) = = 0 ) {
2015-01-27 20:55:16 -05:00
if ( date_fmt & & strlen ( date_fmt ) ) {
2014-11-15 20:28:41 -05:00
if ( ( flags & NO_COLOUR_DATE ) = = 0 ) {
2016-01-20 19:50:55 -05:00
wbkgdset ( window - > layout - > win , theme_attrs ( THEME_TIME ) ) ;
2014-12-15 20:39:47 -05:00
wattron ( window - > layout - > win , theme_attrs ( THEME_TIME ) ) ;
2014-11-15 20:28:41 -05:00
}
2014-12-15 20:39:47 -05:00
wprintw ( window - > layout - > win , " %s %c " , date_fmt , show_char ) ;
2014-11-15 20:28:41 -05:00
if ( ( flags & NO_COLOUR_DATE ) = = 0 ) {
2014-12-15 20:39:47 -05:00
wattroff ( window - > layout - > win , theme_attrs ( THEME_TIME ) ) ;
2014-11-15 20:28:41 -05:00
}
2014-11-08 19:36:25 -05:00
}
2014-06-21 04:16:50 -04:00
}
2013-10-06 14:11:51 -04:00
2016-02-02 16:52:13 -05:00
if ( from & & strlen ( from ) > 0 ) {
2014-07-16 17:56:58 -04:00
if ( flags & NO_ME ) {
2014-11-16 15:40:19 -05:00
colour = theme_attrs ( THEME_THEM ) ;
2014-07-16 17:03:46 -04:00
}
2019-12-12 05:07:11 -05:00
char * color_pref = prefs_get_string ( PREF_COLOR_NICK ) ;
if ( color_pref ! = NULL & & ( strcmp ( color_pref , " false " ) ! = 0 ) ) {
2019-12-03 14:59:18 -05:00
colour = theme_hash_attrs ( from ) ;
}
2019-12-12 05:07:11 -05:00
prefs_free_string ( color_pref ) ;
2019-12-03 14:59:18 -05:00
2014-07-16 17:56:58 -04:00
if ( flags & NO_COLOUR_FROM ) {
2014-07-16 17:03:46 -04:00
colour = 0 ;
}
2015-03-14 12:05:13 -04:00
if ( receipt & & ! receipt - > received ) {
2015-03-15 15:35:25 -04:00
colour = theme_attrs ( THEME_RECEIPT_SENT ) ;
2015-03-14 12:05:13 -04:00
}
2016-01-20 19:50:55 -05:00
wbkgdset ( window - > layout - > win , colour ) ;
2014-12-15 20:39:47 -05:00
wattron ( window - > layout - > win , colour ) ;
2014-07-16 17:03:46 -04:00
if ( strncmp ( message , " /me " , 4 ) = = 0 ) {
2014-12-15 20:39:47 -05:00
wprintw ( window - > layout - > win , " *%s " , from ) ;
2014-07-16 17:03:46 -04:00
offset = 4 ;
2014-11-30 17:50:02 -05:00
me_message = TRUE ;
2014-07-16 17:03:46 -04:00
} else {
2014-12-15 20:39:47 -05:00
wprintw ( window - > layout - > win , " %s: " , from ) ;
wattroff ( window - > layout - > win , colour ) ;
2014-07-16 17:03:46 -04:00
}
2014-06-21 04:16:50 -04:00
}
2014-07-16 17:03:46 -04:00
2014-11-30 17:50:02 -05:00
if ( ! me_message ) {
2015-03-14 12:05:13 -04:00
if ( receipt & & ! receipt - > received ) {
2016-01-20 19:50:55 -05:00
wbkgdset ( window - > layout - > win , theme_attrs ( THEME_RECEIPT_SENT ) ) ;
2015-03-15 15:35:25 -04:00
wattron ( window - > layout - > win , theme_attrs ( THEME_RECEIPT_SENT ) ) ;
2019-06-18 00:23:06 -04:00
} else if ( flags & UNTRUSTED ) {
wbkgdset ( window - > layout - > win , theme_attrs ( THEME_UNTRUSTED ) ) ;
wattron ( window - > layout - > win , theme_attrs ( THEME_UNTRUSTED ) ) ;
2015-03-14 12:05:13 -04:00
} else {
2016-01-20 19:50:55 -05:00
wbkgdset ( window - > layout - > win , theme_attrs ( theme_item ) ) ;
2015-03-14 12:05:13 -04:00
wattron ( window - > layout - > win , theme_attrs ( theme_item ) ) ;
}
2014-11-30 17:50:02 -05:00
}
2014-07-16 17:03:46 -04:00
2014-11-09 18:29:25 -05:00
if ( prefs_get_boolean ( PREF_WRAP ) ) {
2015-07-29 17:48:03 -04:00
_win_print_wrapped ( window - > layout - > win , message + offset , indent , pad_indent ) ;
2014-07-16 17:56:58 -04:00
} else {
2014-12-15 20:39:47 -05:00
wprintw ( window - > layout - > win , " %s " , message + offset ) ;
2014-11-09 18:29:25 -05:00
}
if ( ( flags & NO_EOL ) = = 0 ) {
2015-07-29 18:03:00 -04:00
int curx = getcurx ( window - > layout - > win ) ;
if ( curx ! = 0 ) {
wprintw ( window - > layout - > win , " \n " ) ;
}
2014-07-16 17:03:46 -04:00
}
2014-11-30 17:50:02 -05:00
if ( me_message ) {
2014-12-15 20:39:47 -05:00
wattroff ( window - > layout - > win , colour ) ;
2014-11-30 17:50:02 -05:00
} else {
2015-03-14 12:05:13 -04:00
if ( receipt & & ! receipt - > received ) {
2015-03-15 15:35:25 -04:00
wattroff ( window - > layout - > win , theme_attrs ( THEME_RECEIPT_SENT ) ) ;
2015-03-14 12:05:13 -04:00
} else {
wattroff ( window - > layout - > win , theme_attrs ( theme_item ) ) ;
}
2013-10-06 14:11:51 -04:00
}
2015-08-08 19:40:37 -04:00
g_free ( date_fmt ) ;
2013-10-06 14:11:51 -04:00
}
2014-06-29 09:04:23 -04:00
2014-11-08 16:03:28 -05:00
static void
2014-11-16 11:27:11 -05:00
_win_indent ( WINDOW * win , int size )
2014-11-08 16:03:28 -05:00
{
2014-11-15 20:11:00 -05:00
int i = 0 ;
2014-11-16 11:27:11 -05:00
for ( i = 0 ; i < size ; i + + ) {
waddch ( win , ' ' ) ;
}
}
static void
2015-10-25 19:31:11 -04:00
_win_print_wrapped ( WINDOW * win , const char * const message , size_t indent , int pad_indent )
2014-11-16 11:27:11 -05:00
{
2015-07-29 17:48:03 -04:00
int starty = getcury ( win ) ;
2014-11-08 16:03:28 -05:00
int wordi = 0 ;
char * word = malloc ( strlen ( message ) + 1 ) ;
2015-01-31 19:14:11 -05:00
gchar * curr_ch = g_utf8_offset_to_pointer ( message , 0 ) ;
while ( * curr_ch ! = ' \0 ' ) {
2015-07-29 17:48:03 -04:00
// handle space
2015-01-31 19:14:11 -05:00
if ( * curr_ch = = ' ' ) {
2014-11-16 11:27:11 -05:00
waddch ( win , ' ' ) ;
2015-01-31 19:14:11 -05:00
curr_ch = g_utf8_next_char ( curr_ch ) ;
2015-07-29 17:48:03 -04:00
// handle newline
2015-01-31 19:14:11 -05:00
} else if ( * curr_ch = = ' \n ' ) {
2014-11-15 20:11:00 -05:00
waddch ( win , ' \n ' ) ;
2015-07-29 17:48:03 -04:00
_win_indent ( win , indent + pad_indent ) ;
2015-01-31 19:14:11 -05:00
curr_ch = g_utf8_next_char ( curr_ch ) ;
2015-07-29 17:48:03 -04:00
// handle word
2014-11-08 16:03:28 -05:00
} else {
wordi = 0 ;
2015-07-29 20:31:11 -04:00
int wordlen = 0 ;
2015-01-31 19:14:11 -05:00
while ( * curr_ch ! = ' ' & & * curr_ch ! = ' \n ' & & * curr_ch ! = ' \0 ' ) {
2016-01-25 19:25:13 -05:00
size_t ch_len = mbrlen ( curr_ch , MB_CUR_MAX , NULL ) ;
if ( ( ch_len = = ( size_t ) - 2 ) | | ( ch_len = = ( size_t ) - 1 ) ) {
curr_ch + + ;
continue ;
}
2015-01-31 19:14:11 -05:00
int offset = 0 ;
while ( offset < ch_len ) {
word [ wordi + + ] = curr_ch [ offset + + ] ;
}
curr_ch = g_utf8_next_char ( curr_ch ) ;
2014-11-08 16:03:28 -05:00
}
word [ wordi ] = ' \0 ' ;
2015-07-29 20:31:11 -04:00
wordlen = utf8_display_len ( word ) ;
2014-11-08 16:16:16 -05:00
int curx = getcurx ( win ) ;
2019-07-22 08:27:14 -04:00
int cury ;
2014-11-08 16:16:16 -05:00
int maxx = getmaxx ( win ) ;
2015-07-29 20:31:11 -04:00
// wrap required
if ( curx + wordlen > maxx ) {
int linelen = maxx - ( indent + pad_indent ) ;
// word larger than line
if ( wordlen > linelen ) {
gchar * word_ch = g_utf8_offset_to_pointer ( word , 0 ) ;
while ( * word_ch ! = ' \0 ' ) {
curx = getcurx ( win ) ;
cury = getcury ( win ) ;
gboolean firstline = cury = = starty ;
if ( firstline & & curx < indent ) {
_win_indent ( win , indent ) ;
}
if ( ! firstline & & curx < ( indent + pad_indent ) ) {
_win_indent ( win , indent + pad_indent ) ;
}
gchar copy [ wordi + 1 ] ;
g_utf8_strncpy ( copy , word_ch , 1 ) ;
waddstr ( win , copy ) ;
word_ch = g_utf8_next_char ( word_ch ) ;
}
2015-07-29 17:48:03 -04:00
2015-07-29 20:31:11 -04:00
// newline and print word
} else {
waddch ( win , ' \n ' ) ;
2014-11-09 18:05:53 -05:00
curx = getcurx ( win ) ;
2015-07-29 17:48:03 -04:00
cury = getcury ( win ) ;
2015-07-29 20:31:11 -04:00
gboolean firstline = cury = = starty ;
2015-07-29 17:48:03 -04:00
if ( firstline & & curx < indent ) {
2014-11-16 11:27:11 -05:00
_win_indent ( win , indent ) ;
2014-11-09 18:05:53 -05:00
}
2015-07-29 17:48:03 -04:00
if ( ! firstline & & curx < ( indent + pad_indent ) ) {
_win_indent ( win , indent + pad_indent ) ;
}
2015-07-29 20:31:11 -04:00
waddstr ( win , word ) ;
2014-11-09 18:05:53 -05:00
}
2015-07-29 20:31:11 -04:00
// no wrap required
2014-11-09 18:05:53 -05:00
} else {
2015-07-29 20:31:11 -04:00
curx = getcurx ( win ) ;
cury = getcury ( win ) ;
gboolean firstline = cury = = starty ;
2015-07-29 17:48:03 -04:00
if ( firstline & & curx < indent ) {
2014-11-16 11:27:11 -05:00
_win_indent ( win , indent ) ;
2014-11-09 18:05:53 -05:00
}
2015-07-29 17:48:03 -04:00
if ( ! firstline & & curx < ( indent + pad_indent ) ) {
_win_indent ( win , indent + pad_indent ) ;
}
2015-07-29 20:31:11 -04:00
waddstr ( win , word ) ;
2014-11-08 16:16:16 -05:00
}
2014-11-08 16:03:28 -05:00
}
2015-07-29 17:48:03 -04:00
// consume first space of next line
int curx = getcurx ( win ) ;
int cury = getcury ( win ) ;
gboolean firstline = ( cury = = starty ) ;
if ( ! firstline & & curx = = 0 & & * curr_ch = = ' ' ) {
curr_ch = g_utf8_next_char ( curr_ch ) ;
}
2014-11-08 16:03:28 -05:00
}
free ( word ) ;
}
2019-12-13 06:19:07 -05:00
void
win_print_separator ( ProfWin * window )
{
int cols = getmaxx ( window - > layout - > win ) ;
int i ;
for ( i = 1 ; i < cols ; i + + ) {
wprintw ( window - > layout - > win , " - " ) ;
}
wprintw ( window - > layout - > win , " \n " ) ;
}
2014-07-16 17:03:46 -04:00
void
win_redraw ( ProfWin * window )
{
2014-06-29 09:04:23 -04:00
int i , size ;
2014-12-15 20:39:47 -05:00
werase ( window - > layout - > win ) ;
size = buffer_size ( window - > layout - > buffer ) ;
2014-07-16 17:03:46 -04:00
for ( i = 0 ; i < size ; i + + ) {
2016-10-16 14:40:43 -04:00
ProfBuffEntry * e = buffer_get_entry ( window - > layout - > buffer , i ) ;
2019-12-13 06:19:07 -05:00
2020-02-13 09:55:10 -05:00
if ( e - > display_from = = NULL & & e - > message & & e - > message [ 0 ] = = ' - ' ) {
2019-12-13 06:47:27 -05:00
// just an indicator to print the separator not the actual message
2019-12-13 06:19:07 -05:00
win_print_separator ( window ) ;
} else {
2019-12-13 06:47:27 -05:00
// regular thing to print
2020-02-13 09:55:10 -05:00
_win_print_internal ( window , e - > show_char , e - > pad_indent , e - > time , e - > flags , e - > theme_item , e - > display_from , e - > message , e - > receipt ) ;
2019-12-13 06:19:07 -05:00
}
2014-06-29 09:04:23 -04:00
}
2014-07-18 17:28:49 -04:00
}
2014-11-10 17:47:53 -05:00
2014-12-15 20:39:47 -05:00
gboolean
win_has_active_subwin ( ProfWin * window )
{
if ( window - > layout - > type = = LAYOUT_SPLIT ) {
ProfLayoutSplit * layout = ( ProfLayoutSplit * ) window - > layout ;
return ( layout - > subwin ! = NULL ) ;
} else {
return FALSE ;
}
}
2015-11-25 17:08:33 -05:00
gboolean
2016-02-06 20:15:40 -05:00
win_notify_remind ( ProfWin * window )
2015-11-25 17:08:33 -05:00
{
2016-02-03 20:24:37 -05:00
switch ( window - > type ) {
case WIN_CHAT :
{
2015-11-25 17:08:33 -05:00
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
2016-02-03 20:24:37 -05:00
if ( prefs_get_boolean ( PREF_NOTIFY_CHAT ) & & chatwin - > unread > 0 ) {
return TRUE ;
} else {
return FALSE ;
}
}
case WIN_MUC :
{
2015-11-25 17:08:33 -05:00
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
2016-02-03 20:24:37 -05:00
2016-02-06 20:15:40 -05:00
return prefs_do_room_notify_mention ( mucwin - > roomjid , mucwin - > unread , mucwin - > unread_mentions , mucwin - > unread_triggers ) ;
2016-02-03 20:24:37 -05:00
}
case WIN_PRIVATE :
{
2015-11-25 17:08:33 -05:00
ProfPrivateWin * privatewin = ( ProfPrivateWin * ) window ;
assert ( privatewin - > memcheck = = PROFPRIVATEWIN_MEMCHECK ) ;
2016-02-03 20:24:37 -05:00
if ( prefs_get_boolean ( PREF_NOTIFY_CHAT ) & & privatewin - > unread > 0 ) {
return TRUE ;
} else {
return FALSE ;
}
}
default :
2015-11-25 17:08:33 -05:00
return FALSE ;
}
}
2014-12-21 18:14:01 -05:00
int
win_unread ( ProfWin * window )
{
if ( window - > type = = WIN_CHAT ) {
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
return chatwin - > unread ;
} else if ( window - > type = = WIN_MUC ) {
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
return mucwin - > unread ;
} else if ( window - > type = = WIN_PRIVATE ) {
ProfPrivateWin * privatewin = ( ProfPrivateWin * ) window ;
assert ( privatewin - > memcheck = = PROFPRIVATEWIN_MEMCHECK ) ;
return privatewin - > unread ;
} else {
return 0 ;
}
}
2014-11-10 17:47:53 -05:00
void
2015-11-21 20:39:20 -05:00
win_sub_print ( WINDOW * win , char * msg , gboolean newline , gboolean wrap , int indent )
2014-11-10 17:47:53 -05:00
{
int maxx = getmaxx ( win ) ;
2015-11-21 19:30:42 -05:00
int curx = getcurx ( win ) ;
2014-11-10 17:47:53 -05:00
int cury = getcury ( win ) ;
2015-11-21 20:39:20 -05:00
if ( wrap ) {
_win_print_wrapped ( win , msg , 1 , indent ) ;
} else {
waddnstr ( win , msg , maxx - curx ) ;
}
2014-11-10 19:54:10 -05:00
2015-11-21 16:03:53 -05:00
if ( newline ) {
wmove ( win , cury + 1 , 0 ) ;
}
2015-01-08 17:43:11 -05:00
}
2015-11-21 19:30:42 -05:00
void
2015-11-21 19:54:40 -05:00
win_sub_newline_lazy ( WINDOW * win )
2015-11-21 19:30:42 -05:00
{
int curx = getcurx ( win ) ;
if ( curx > 0 ) {
int cury = getcury ( win ) ;
wmove ( win , cury + 1 , 0 ) ;
}
}
2018-03-21 22:27:52 -04:00
void
win_command_list_error ( ProfWin * window , const char * const error )
{
assert ( window ! = NULL ) ;
win_println ( window , THEME_ERROR , ' ! ' , " Error retrieving command list: %s " , error ) ;
}
2018-03-23 14:49:48 -04:00
void
win_command_exec_error ( ProfWin * window , const char * const command , const char * const error , . . . )
{
assert ( window ! = NULL ) ;
va_list arg ;
va_start ( arg , error ) ;
GString * msg = g_string_new ( NULL ) ;
g_string_vprintf ( msg , error , arg ) ;
2018-09-05 08:17:26 -04:00
win_println ( window , THEME_ERROR , ' ! ' , " Error executing command %s: %s " , command , msg - > str ) ;
2018-03-23 14:49:48 -04:00
g_string_free ( msg , TRUE ) ;
va_end ( arg ) ;
}
2018-03-21 22:27:52 -04:00
void
win_handle_command_list ( ProfWin * window , GSList * cmds )
{
assert ( window ! = NULL ) ;
if ( cmds ) {
win_println ( window , THEME_DEFAULT , ' ! ' , " Ad hoc commands: " ) ;
GSList * curr_cmd = cmds ;
while ( curr_cmd ) {
const char * cmd = curr_cmd - > data ;
win_println ( window , THEME_DEFAULT , ' ! ' , " %s " , cmd ) ;
curr_cmd = g_slist_next ( curr_cmd ) ;
}
win_println ( window , THEME_DEFAULT , ' ! ' , " " ) ;
} else {
win_println ( window , THEME_DEFAULT , ' ! ' , " No commands found " ) ;
win_println ( window , THEME_DEFAULT , ' ! ' , " " ) ;
}
}
2018-03-22 16:01:15 -04:00
2018-05-30 13:25:06 -04:00
void
win_handle_command_exec_status ( ProfWin * window , const char * const command , const char * const value )
{
assert ( window ! = NULL ) ;
win_println ( window , THEME_DEFAULT , ' ! ' , " %s %s " , command , value ) ;
}
2018-03-22 16:01:15 -04:00
void
win_handle_command_exec_result_note ( ProfWin * window , const char * const type , const char * const value )
{
assert ( window ! = NULL ) ;
win_println ( window , THEME_DEFAULT , ' ! ' , value ) ;
}
2019-12-13 06:05:24 -05:00
void
win_insert_last_read_position_marker ( ProfWin * window , char * id )
{
2019-12-13 06:47:27 -05:00
int i , size ;
size = buffer_size ( window - > layout - > buffer ) ;
// TODO: this is somewhat costly. We should improve this later.
// check if we already have a separator present
for ( i = 0 ; i < size ; i + + ) {
ProfBuffEntry * e = buffer_get_entry ( window - > layout - > buffer , i ) ;
// if yes, don't print a new one
if ( e - > id & & ( g_strcmp0 ( e - > id , id ) = = 0 ) ) {
return ;
}
}
2019-12-13 06:05:24 -05:00
GDateTime * time = g_date_time_new_now_local ( ) ;
2019-12-13 06:47:27 -05:00
// the separator will actually be print in win_redraw().
// this only puts it in the buffer and win_redraw() will interpret it.
// so that we have the correct length even when resizing.
2019-12-13 06:19:07 -05:00
buffer_append ( window - > layout - > buffer , ' ' , 0 , time , 0 , THEME_TEXT , NULL , " - " , NULL , id ) ;
2019-12-13 06:05:24 -05:00
win_redraw ( window ) ;
g_date_time_unref ( time ) ;
}