Mercurial > ~mikael > mcabber > hg
annotate mcabber/src/screen.c @ 715:be9f6224c3ca
Do not show the roster when it is hidden and we're moving in the roster
The currently selected buddy is now shown in the chat status line, so
there is no reason to automatically reenable the roster anymore.
| author | Mikael Berthe <mikael@lilotux.net> |
|---|---|
| date | Sat, 04 Mar 2006 22:16:39 +0100 |
| parents | 4bcd48f6ca5f |
| children | ba1137a01078 |
| rev | line source |
|---|---|
| 307 | 1 /* |
| 2 * screen.c -- UI stuff | |
| 393 | 3 * |
| 699 | 4 * Copyright (C) 2005, 2006 Mikael Berthe <bmikael@lists.lilotux.net> |
| 307 | 5 * Parts of this file come from the Cabber project <cabber@ajmacias.com> |
| 6 * | |
| 7 * This program is free software; you can redistribute it and/or modify | |
| 8 * it under the terms of the GNU General Public License as published by | |
| 9 * the Free Software Foundation; either version 2 of the License, or (at | |
| 10 * your option) any later version. | |
| 11 * | |
| 12 * This program is distributed in the hope that it will be useful, but | |
| 13 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 15 * General Public License for more details. | |
| 16 * | |
| 17 * You should have received a copy of the GNU General Public License | |
| 18 * along with this program; if not, write to the Free Software | |
| 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 | |
| 20 * USA | |
| 21 */ | |
| 22 | |
| 24 | 23 #include <stdio.h> |
| 24 #include <stdlib.h> | |
| 25 #include <string.h> | |
| 26 #include <ncurses.h> | |
| 27 #include <panel.h> | |
| 28 #include <time.h> | |
| 29 #include <ctype.h> | |
| 30 #include <locale.h> | |
| 232 | 31 #include <langinfo.h> |
| 24 | 32 |
| 33 #include "screen.h" | |
| 81 | 34 #include "hbuf.h" |
| 47 | 35 #include "commands.h" |
| 95 | 36 #include "compl.h" |
| 81 | 37 #include "roster.h" |
| 180 | 38 #include "histolog.h" |
|
279
f5dd437c057b
Rewrite the settings system
Mikael Berthe <mikael@lilotux.net>
parents:
276
diff
changeset
|
39 #include "settings.h" |
| 81 | 40 #include "utils.h" |
| 24 | 41 #include "list.h" |
| 42 | |
| 43 #define window_entry(n) list_entry(n, window_entry_t, list) | |
| 44 | |
|
515
180f0a6e4ac9
Log window's height can be set by the user
Mikael Berthe <mikael@lilotux.net>
parents:
514
diff
changeset
|
45 #define DEFAULT_LOG_WIN_HEIGHT (5+2) |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
46 #define DEFAULT_ROSTER_WIDTH 24 |
|
515
180f0a6e4ac9
Log window's height can be set by the user
Mikael Berthe <mikael@lilotux.net>
parents:
514
diff
changeset
|
47 #define CHAT_WIN_HEIGHT (maxY-1-Log_Win_Height) |
|
180f0a6e4ac9
Log window's height can be set by the user
Mikael Berthe <mikael@lilotux.net>
parents:
514
diff
changeset
|
48 |
|
592
67a332121aea
Try UTF8 -> locale conversion with fallback
Mikael Berthe <mikael@lilotux.net>
parents:
580
diff
changeset
|
49 char *LocaleCharSet = "C"; |
|
67a332121aea
Try UTF8 -> locale conversion with fallback
Mikael Berthe <mikael@lilotux.net>
parents:
580
diff
changeset
|
50 |
|
515
180f0a6e4ac9
Log window's height can be set by the user
Mikael Berthe <mikael@lilotux.net>
parents:
514
diff
changeset
|
51 static unsigned short int Log_Win_Height; |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
52 static unsigned short int Roster_Width; |
|
515
180f0a6e4ac9
Log window's height can be set by the user
Mikael Berthe <mikael@lilotux.net>
parents:
514
diff
changeset
|
53 |
|
336
eb994ee40029
Make some functions static
Mikael Berthe <mikael@lilotux.net>
parents:
332
diff
changeset
|
54 static inline void check_offset(int); |
| 151 | 55 |
| 24 | 56 LIST_HEAD(window_list); |
| 57 | |
| 58 typedef struct _window_entry_t { | |
| 59 WINDOW *win; | |
| 108 | 60 PANEL *panel; |
| 61 char *name; | |
| 62 GList *hbuf; | |
| 181 | 63 GList *top; // If top is NULL, we'll display the last lines |
| 64 char cleared; // For ex, user has issued a /clear command... | |
| 24 | 65 struct list_head list; |
| 66 } window_entry_t; | |
| 67 | |
| 68 | |
| 711 | 69 static WINDOW *rosterWnd, *chatWnd, *inputWnd, *logWnd; |
| 70 static WINDOW *mainstatusWnd, *chatstatusWnd; | |
| 24 | 71 static PANEL *rosterPanel, *chatPanel, *inputPanel; |
| 711 | 72 static PANEL *mainstatusPanel, *chatstatusPanel; |
| 73 static PANEL *logPanel; | |
| 24 | 74 static int maxY, maxX; |
| 75 static window_entry_t *currentWindow; | |
| 76 | |
|
707
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
77 static int roster_hidden; |
| 24 | 78 static int chatmode; |
| 238 | 79 static int multimode; |
| 80 static char *multiline; | |
| 30 | 81 int update_roster; |
| 232 | 82 int utf8_mode = 0; |
|
322
da138cdebf04
Implement auto-away mode
Mikael Berthe <mikael@lilotux.net>
parents:
314
diff
changeset
|
83 static bool Autoaway; |
|
332
a1901741890e
scr_LogPrint() can be called before ncurses initialization
Mikael Berthe <mikael@lilotux.net>
parents:
330
diff
changeset
|
84 static bool Curses; |
| 24 | 85 |
| 174 | 86 static char inputLine[INPUTLINE_LENGTH+1]; |
| 87 static char *ptr_inputline; | |
| 88 static short int inputline_offset; | |
| 89 static int completion_started; | |
| 173 | 90 static GList *cmdhisto; |
| 91 static GList *cmdhisto_cur; | |
| 174 | 92 static char cmdhisto_backup[INPUTLINE_LENGTH+1]; |
| 24 | 93 |
| 94 | |
| 99 | 95 /* Functions */ |
| 24 | 96 |
|
336
eb994ee40029
Make some functions static
Mikael Berthe <mikael@lilotux.net>
parents:
332
diff
changeset
|
97 static int scr_WindowWidth(WINDOW * win) |
| 24 | 98 { |
| 99 int x, y; | |
| 100 getmaxyx(win, y, x); | |
| 101 return x; | |
| 102 } | |
| 103 | |
|
336
eb994ee40029
Make some functions static
Mikael Berthe <mikael@lilotux.net>
parents:
332
diff
changeset
|
104 static int FindColor(const char *name) |
| 24 | 105 { |
| 106 if (!strcmp(name, "default")) | |
| 107 return -1; | |
| 108 if (!strcmp(name, "black")) | |
| 109 return COLOR_BLACK; | |
| 110 if (!strcmp(name, "red")) | |
| 111 return COLOR_RED; | |
| 112 if (!strcmp(name, "green")) | |
| 113 return COLOR_GREEN; | |
| 114 if (!strcmp(name, "yellow")) | |
| 115 return COLOR_YELLOW; | |
| 116 if (!strcmp(name, "blue")) | |
| 117 return COLOR_BLUE; | |
| 118 if (!strcmp(name, "magenta")) | |
| 119 return COLOR_MAGENTA; | |
| 120 if (!strcmp(name, "cyan")) | |
| 121 return COLOR_CYAN; | |
| 122 if (!strcmp(name, "white")) | |
| 123 return COLOR_WHITE; | |
| 124 | |
| 125 return -1; | |
| 126 } | |
| 127 | |
|
336
eb994ee40029
Make some functions static
Mikael Berthe <mikael@lilotux.net>
parents:
332
diff
changeset
|
128 static void ParseColors(void) |
| 24 | 129 { |
|
281
f562b9af2de7
Add "const" specifier in prototypes
Mikael Berthe <mikael@lilotux.net>
parents:
279
diff
changeset
|
130 const char *colors[8] = { |
| 24 | 131 "", "", |
| 267 | 132 "general", |
| 711 | 133 "status", |
| 712 | 134 "roster", |
| 135 "rostersel", | |
| 136 "rosternewmsg", | |
| 24 | 137 NULL |
| 138 }; | |
| 139 | |
|
657
056dc9e65c25
Some memory allocation code cleaning
Mikael Berthe <mikael@lilotux.net>
parents:
654
diff
changeset
|
140 char *tmp = g_new(char, 512); |
|
281
f562b9af2de7
Add "const" specifier in prototypes
Mikael Berthe <mikael@lilotux.net>
parents:
279
diff
changeset
|
141 const char *color; |
|
f562b9af2de7
Add "const" specifier in prototypes
Mikael Berthe <mikael@lilotux.net>
parents:
279
diff
changeset
|
142 const char *background = settings_opt_get("color_background"); |
| 712 | 143 const char *backselected = settings_opt_get("color_bgrostersel"); |
| 144 const char *backstatus = settings_opt_get("color_bgstatus"); | |
| 24 | 145 int i = 0; |
| 146 | |
| 267 | 147 // Default values |
| 711 | 148 if (!background) background = "black"; |
| 267 | 149 if (!backselected) backselected = "cyan"; |
| 711 | 150 if (!backstatus) backstatus = "blue"; |
| 267 | 151 |
| 24 | 152 while (colors[i]) { |
|
657
056dc9e65c25
Some memory allocation code cleaning
Mikael Berthe <mikael@lilotux.net>
parents:
654
diff
changeset
|
153 snprintf(tmp, 512, "color_%s", colors[i]); |
|
279
f5dd437c057b
Rewrite the settings system
Mikael Berthe <mikael@lilotux.net>
parents:
276
diff
changeset
|
154 color = settings_opt_get(tmp); |
| 24 | 155 |
| 156 switch (i + 1) { | |
| 157 case 1: | |
| 158 init_pair(1, COLOR_BLACK, COLOR_WHITE); | |
| 159 break; | |
| 160 case 2: | |
| 161 init_pair(2, COLOR_WHITE, COLOR_BLACK); | |
| 162 break; | |
| 711 | 163 case COLOR_GENERAL: |
| 164 init_pair(i+1, ((color) ? FindColor(color) : COLOR_WHITE), | |
| 267 | 165 FindColor(background)); |
| 24 | 166 break; |
| 711 | 167 case COLOR_STATUS: |
| 168 init_pair(i+1, ((color) ? FindColor(color) : COLOR_WHITE), | |
| 169 FindColor(backstatus)); | |
| 170 break; | |
| 712 | 171 case COLOR_ROSTER: |
| 172 init_pair(i+1, ((color) ? FindColor(color) : COLOR_GREEN), | |
| 267 | 173 FindColor(background)); |
| 24 | 174 break; |
| 712 | 175 case COLOR_ROSTERSEL: |
| 711 | 176 init_pair(i+1, ((color) ? FindColor(color) : COLOR_BLUE), |
| 267 | 177 FindColor(backselected)); |
| 24 | 178 break; |
| 712 | 179 case COLOR_ROSTERNMSG: |
| 180 init_pair(i+1, ((color) ? FindColor(color) : COLOR_RED), | |
| 267 | 181 FindColor(background)); |
| 24 | 182 break; |
| 183 } | |
| 184 i++; | |
| 185 } | |
| 186 } | |
| 187 | |
|
373
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
188 void scr_InitCurses(void) |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
189 { |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
190 initscr(); |
|
382
4c6e8392e465
Use nodelay() instead of halfdelay()
Mikael Berthe <mikael@lilotux.net>
parents:
374
diff
changeset
|
191 raw(); |
|
373
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
192 noecho(); |
|
389
6e895f397474
Ncurses changes + Ctrl-C does not send a signal anylore
Mikael Berthe <mikael@lilotux.net>
parents:
388
diff
changeset
|
193 nonl(); |
|
6e895f397474
Ncurses changes + Ctrl-C does not send a signal anylore
Mikael Berthe <mikael@lilotux.net>
parents:
388
diff
changeset
|
194 intrflush(stdscr, FALSE); |
|
373
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
195 start_color(); |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
196 use_default_colors(); |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
197 Curses = TRUE; |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
198 |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
199 ParseColors(); |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
200 |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
201 getmaxyx(stdscr, maxY, maxX); |
|
515
180f0a6e4ac9
Log window's height can be set by the user
Mikael Berthe <mikael@lilotux.net>
parents:
514
diff
changeset
|
202 Log_Win_Height = DEFAULT_LOG_WIN_HEIGHT; |
|
518
9480a76471b6
Update Log_Win_Height when refreshing the screen
Mikael Berthe <mikael@lilotux.net>
parents:
515
diff
changeset
|
203 // Note scr_DrawMainWindow() should be called early after scr_InitCurses() |
|
9480a76471b6
Update Log_Win_Height when refreshing the screen
Mikael Berthe <mikael@lilotux.net>
parents:
515
diff
changeset
|
204 // to update Log_Win_Height and set max{X,Y} |
|
515
180f0a6e4ac9
Log window's height can be set by the user
Mikael Berthe <mikael@lilotux.net>
parents:
514
diff
changeset
|
205 |
|
373
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
206 inputLine[0] = 0; |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
207 ptr_inputline = inputLine; |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
208 |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
209 setlocale(LC_CTYPE, ""); |
|
592
67a332121aea
Try UTF8 -> locale conversion with fallback
Mikael Berthe <mikael@lilotux.net>
parents:
580
diff
changeset
|
210 LocaleCharSet = nl_langinfo(CODESET); |
|
67a332121aea
Try UTF8 -> locale conversion with fallback
Mikael Berthe <mikael@lilotux.net>
parents:
580
diff
changeset
|
211 utf8_mode = (strcmp(LocaleCharSet, "UTF-8") == 0); |
|
373
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
212 |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
213 return; |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
214 } |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
215 |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
216 void scr_TerminateCurses(void) |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
217 { |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
218 if (!Curses) return; |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
219 clear(); |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
220 refresh(); |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
221 endwin(); |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
222 Curses = FALSE; |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
223 return; |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
224 } |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
225 |
|
675
ae7016aae014
New "beep_on_message" option
Mikael Berthe <mikael@lilotux.net>
parents:
667
diff
changeset
|
226 inline void scr_Beep(void) |
|
ae7016aae014
New "beep_on_message" option
Mikael Berthe <mikael@lilotux.net>
parents:
667
diff
changeset
|
227 { |
|
ae7016aae014
New "beep_on_message" option
Mikael Berthe <mikael@lilotux.net>
parents:
667
diff
changeset
|
228 beep(); |
|
ae7016aae014
New "beep_on_message" option
Mikael Berthe <mikael@lilotux.net>
parents:
667
diff
changeset
|
229 } |
|
ae7016aae014
New "beep_on_message" option
Mikael Berthe <mikael@lilotux.net>
parents:
667
diff
changeset
|
230 |
|
373
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
231 // scr_LogPrint(...) |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
232 // Display a message in the log window. |
|
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
233 void scr_LogPrint(unsigned int flag, const char *fmt, ...) |
|
373
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
234 { |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
235 time_t timestamp; |
|
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
236 char *buffer, *b2; |
|
373
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
237 va_list ap; |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
238 |
|
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
239 if (!flag) return; |
|
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
240 |
|
602
7b20c27cae48
Increase scr_LogPrint() buffer size
Mikael Berthe <mikael@lilotux.net>
parents:
592
diff
changeset
|
241 buffer = g_new(char, 5184); |
|
373
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
242 |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
243 timestamp = time(NULL); |
|
602
7b20c27cae48
Increase scr_LogPrint() buffer size
Mikael Berthe <mikael@lilotux.net>
parents:
592
diff
changeset
|
244 strftime(buffer, 48, "[%H:%M:%S] ", localtime(×tamp)); |
|
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
245 for (b2 = buffer ; *b2 ; b2++) |
|
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
246 ; |
|
373
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
247 va_start(ap, fmt); |
|
602
7b20c27cae48
Increase scr_LogPrint() buffer size
Mikael Berthe <mikael@lilotux.net>
parents:
592
diff
changeset
|
248 vsnprintf(b2, 5120, fmt, ap); |
|
373
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
249 va_end(ap); |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
250 |
|
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
251 if (flag & LPRINT_NORMAL) { |
|
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
252 if (Curses) { |
|
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
253 wprintw(logWnd, "\n%s", buffer); |
|
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
254 update_panels(); |
|
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
255 doupdate(); |
|
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
256 } else { |
|
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
257 printf("%s\n", buffer); |
|
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
258 } |
|
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
259 } |
|
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
260 if (flag & (LPRINT_LOG|LPRINT_DEBUG)) { |
| 658 | 261 char *buffer2 = g_new(char, 5184); |
|
412
9c640ee3bae3
Display full date in the log file
Mikael Berthe <mikael@lilotux.net>
parents:
393
diff
changeset
|
262 |
| 658 | 263 strftime(buffer2, 23, "[%Y-%m-%d %H:%M:%S] ", localtime(×tamp)); |
| 264 strcat(buffer2, b2); | |
|
412
9c640ee3bae3
Display full date in the log file
Mikael Berthe <mikael@lilotux.net>
parents:
393
diff
changeset
|
265 strcat(buffer2, "\n"); |
|
9c640ee3bae3
Display full date in the log file
Mikael Berthe <mikael@lilotux.net>
parents:
393
diff
changeset
|
266 ut_WriteLog(flag, buffer2); |
| 658 | 267 g_free(buffer2); |
|
373
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
268 } |
|
602
7b20c27cae48
Increase scr_LogPrint() buffer size
Mikael Berthe <mikael@lilotux.net>
parents:
592
diff
changeset
|
269 g_free(buffer); |
|
373
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
270 } |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
271 |
|
336
eb994ee40029
Make some functions static
Mikael Berthe <mikael@lilotux.net>
parents:
332
diff
changeset
|
272 static window_entry_t *scr_CreateBuddyPanel(const char *title, int dont_show) |
| 24 | 273 { |
| 151 | 274 int x; |
| 275 int y; | |
| 276 int lines; | |
| 277 int cols; | |
| 153 | 278 window_entry_t *tmp; |
| 393 | 279 |
|
657
056dc9e65c25
Some memory allocation code cleaning
Mikael Berthe <mikael@lilotux.net>
parents:
654
diff
changeset
|
280 tmp = g_new0(window_entry_t, 1); |
| 24 | 281 |
| 151 | 282 // Dimensions |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
283 x = Roster_Width; |
| 151 | 284 y = 0; |
| 285 lines = CHAT_WIN_HEIGHT; | |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
286 cols = maxX - Roster_Width; |
|
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
287 if (cols < 1) cols = 1; |
| 151 | 288 |
| 24 | 289 tmp->win = newwin(lines, cols, y, x); |
| 154 | 290 while (!tmp->win) { |
| 419 | 291 safe_usleep(250); |
| 154 | 292 tmp->win = newwin(lines, cols, y, x); |
| 293 } | |
| 168 | 294 wbkgd(tmp->win, COLOR_PAIR(COLOR_GENERAL)); |
| 24 | 295 tmp->panel = new_panel(tmp->win); |
|
657
056dc9e65c25
Some memory allocation code cleaning
Mikael Berthe <mikael@lilotux.net>
parents:
654
diff
changeset
|
296 tmp->name = g_strdup(title); |
| 24 | 297 |
| 143 | 298 if (!dont_show) { |
| 24 | 299 currentWindow = tmp; |
| 300 } else { | |
| 301 if (currentWindow) | |
| 302 top_panel(currentWindow->panel); | |
| 303 else | |
| 304 top_panel(chatPanel); | |
| 305 } | |
| 143 | 306 update_panels(); |
| 24 | 307 |
| 181 | 308 // Load buddy history from file (if enabled) |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
309 hlog_read_history(title, &tmp->hbuf, maxX - Roster_Width - PREFIX_WIDTH); |
| 181 | 310 |
| 24 | 311 list_add_tail(&tmp->list, &window_list); |
| 312 | |
| 313 return tmp; | |
| 314 } | |
| 315 | |
|
336
eb994ee40029
Make some functions static
Mikael Berthe <mikael@lilotux.net>
parents:
332
diff
changeset
|
316 static window_entry_t *scr_SearchWindow(const char *winId) |
| 24 | 317 { |
| 318 struct list_head *pos, *n; | |
| 319 window_entry_t *search_entry = NULL; | |
| 320 | |
|
361
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
321 if (!winId) return NULL; |
|
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
322 |
| 24 | 323 list_for_each_safe(pos, n, &window_list) { |
| 324 search_entry = window_entry(pos); | |
| 325 if (search_entry->name) { | |
| 326 if (!strcasecmp(search_entry->name, winId)) { | |
| 327 return search_entry; | |
| 328 } | |
| 329 } | |
| 330 } | |
| 331 return NULL; | |
| 332 } | |
| 333 | |
|
514
979eb0fe2969
Show status changes in buddy window, if it is open
Mikael Berthe <mikael@lilotux.net>
parents:
513
diff
changeset
|
334 bool scr_BuddyBufferExists(const char *jid) |
|
979eb0fe2969
Show status changes in buddy window, if it is open
Mikael Berthe <mikael@lilotux.net>
parents:
513
diff
changeset
|
335 { |
|
979eb0fe2969
Show status changes in buddy window, if it is open
Mikael Berthe <mikael@lilotux.net>
parents:
513
diff
changeset
|
336 return (scr_SearchWindow(jid) != NULL); |
|
979eb0fe2969
Show status changes in buddy window, if it is open
Mikael Berthe <mikael@lilotux.net>
parents:
513
diff
changeset
|
337 } |
|
979eb0fe2969
Show status changes in buddy window, if it is open
Mikael Berthe <mikael@lilotux.net>
parents:
513
diff
changeset
|
338 |
| 143 | 339 // scr_UpdateWindow() |
| 340 // (Re-)Display the given chat window. | |
|
336
eb994ee40029
Make some functions static
Mikael Berthe <mikael@lilotux.net>
parents:
332
diff
changeset
|
341 static void scr_UpdateWindow(window_entry_t *win_entry) |
| 74 | 342 { |
| 343 int n; | |
| 344 int width; | |
| 184 | 345 hbb_line **lines, *line; |
| 74 | 346 GList *hbuf_head; |
| 184 | 347 char date[32]; |
| 74 | 348 |
| 108 | 349 width = scr_WindowWidth(win_entry->win); |
| 350 | |
| 351 // Should the window be empty? | |
| 352 if (win_entry->cleared) { | |
| 168 | 353 werase(win_entry->win); |
| 108 | 354 return; |
| 355 } | |
| 356 | |
| 105 | 357 // win_entry->top is the top message of the screen. If it set to NULL, we |
| 358 // are displaying the last messages. | |
| 359 | |
| 74 | 360 // We will show the last CHAT_WIN_HEIGHT lines. |
| 361 // Let's find out where it begins. | |
| 105 | 362 if (!win_entry->top || |
| 363 (g_list_position(g_list_first(win_entry->hbuf), win_entry->top) == -1)) { | |
| 364 // Move up CHAT_WIN_HEIGHT lines | |
| 365 win_entry->hbuf = g_list_last(win_entry->hbuf); | |
| 366 hbuf_head = win_entry->hbuf; | |
| 367 win_entry->top = NULL; // (Just to make sure) | |
| 368 n = 0; | |
| 369 while (hbuf_head && (n < CHAT_WIN_HEIGHT-1) && g_list_previous(hbuf_head)) { | |
| 370 hbuf_head = g_list_previous(hbuf_head); | |
| 371 n++; | |
| 372 } | |
| 373 } else | |
| 374 hbuf_head = win_entry->top; | |
| 74 | 375 |
| 376 // Get the last CHAT_WIN_HEIGHT lines. | |
| 377 lines = hbuf_get_lines(hbuf_head, CHAT_WIN_HEIGHT); | |
| 378 | |
| 379 // Display these lines | |
| 380 for (n = 0; n < CHAT_WIN_HEIGHT; n++) { | |
| 168 | 381 wmove(win_entry->win, n, 0); |
| 184 | 382 line = *(lines+n); |
| 185 | 383 // NOTE: update PREFIX_WIDTH if you change the date format!! |
| 384 // You need to set it to the whole prefix length + 1 | |
| 184 | 385 if (line) { |
| 386 if (line->timestamp) { | |
| 419 | 387 strftime(date, 30, "%m-%d %H:%M", localtime(&line->timestamp)); |
| 184 | 388 } else |
| 185 | 389 strcpy(date, " "); |
| 197 | 390 if (line->flags & HBB_PREFIX_INFO) { |
| 391 char dir = '*'; | |
| 392 if (line->flags & HBB_PREFIX_IN) | |
| 393 dir = '<'; | |
| 394 else if (line->flags & HBB_PREFIX_OUT) | |
| 395 dir = '>'; | |
| 396 wprintw(win_entry->win, "%.11s *%c* ", date, dir); | |
|
325
ff6fb51bfd78
Handle "error" message type
Mikael Berthe <mikael@lilotux.net>
parents:
322
diff
changeset
|
397 } else if (line->flags & HBB_PREFIX_ERR) { |
|
ff6fb51bfd78
Handle "error" message type
Mikael Berthe <mikael@lilotux.net>
parents:
322
diff
changeset
|
398 char dir = '#'; |
|
ff6fb51bfd78
Handle "error" message type
Mikael Berthe <mikael@lilotux.net>
parents:
322
diff
changeset
|
399 if (line->flags & HBB_PREFIX_IN) |
|
ff6fb51bfd78
Handle "error" message type
Mikael Berthe <mikael@lilotux.net>
parents:
322
diff
changeset
|
400 dir = '<'; |
|
ff6fb51bfd78
Handle "error" message type
Mikael Berthe <mikael@lilotux.net>
parents:
322
diff
changeset
|
401 else if (line->flags & HBB_PREFIX_OUT) |
|
ff6fb51bfd78
Handle "error" message type
Mikael Berthe <mikael@lilotux.net>
parents:
322
diff
changeset
|
402 dir = '>'; |
|
ff6fb51bfd78
Handle "error" message type
Mikael Berthe <mikael@lilotux.net>
parents:
322
diff
changeset
|
403 wprintw(win_entry->win, "%.11s #%c# ", date, dir); |
| 197 | 404 } else if (line->flags & HBB_PREFIX_IN) |
| 185 | 405 wprintw(win_entry->win, "%.11s <== ", date); |
| 184 | 406 else if (line->flags & HBB_PREFIX_OUT) |
| 185 | 407 wprintw(win_entry->win, "%.11s --> ", date); |
| 75 | 408 else { |
| 185 | 409 wprintw(win_entry->win, "%.11s ", date); |
| 75 | 410 } |
| 184 | 411 wprintw(win_entry->win, "%s", line->text); // line |
| 168 | 412 wclrtoeol(win_entry->win); |
| 184 | 413 g_free(line->text); |
| 168 | 414 } else { |
| 415 wclrtobot(win_entry->win); | |
| 416 break; | |
| 75 | 417 } |
| 74 | 418 } |
| 419 g_free(lines); | |
| 420 } | |
| 421 | |
| 143 | 422 // scr_ShowWindow() |
| 423 // Display the chat window with the given identifier. | |
|
336
eb994ee40029
Make some functions static
Mikael Berthe <mikael@lilotux.net>
parents:
332
diff
changeset
|
424 static void scr_ShowWindow(const char *winId) |
| 24 | 425 { |
| 74 | 426 window_entry_t *win_entry = scr_SearchWindow(winId); |
| 427 | |
| 181 | 428 if (!win_entry) |
| 180 | 429 win_entry = scr_CreateBuddyPanel(winId, FALSE); |
| 74 | 430 |
| 180 | 431 top_panel(win_entry->panel); |
| 432 currentWindow = win_entry; | |
| 433 chatmode = TRUE; | |
| 434 roster_msg_setflag(winId, FALSE); | |
| 435 roster_setflags(winId, ROSTER_FLAG_LOCK, TRUE); | |
| 436 update_roster = TRUE; | |
| 74 | 437 |
| 180 | 438 // Refresh the window |
| 439 scr_UpdateWindow(win_entry); | |
| 440 | |
| 441 // Finished :) | |
| 442 update_panels(); | |
| 142 | 443 |
| 444 top_panel(inputPanel); | |
| 24 | 445 } |
| 446 | |
| 143 | 447 // scr_ShowBuddyWindow() |
| 448 // Display the chat window buffer for the current buddy. | |
| 24 | 449 void scr_ShowBuddyWindow(void) |
| 450 { | |
| 105 | 451 const gchar *jid; |
| 140 | 452 |
| 105 | 453 if (!current_buddy) |
| 140 | 454 jid = NULL; |
| 455 else | |
| 456 jid = CURRENT_JID; | |
| 457 | |
| 458 if (!jid) { | |
| 459 top_panel(chatPanel); | |
| 143 | 460 top_panel(inputPanel); |
| 140 | 461 currentWindow = NULL; |
| 105 | 462 return; |
| 140 | 463 } |
| 464 | |
| 105 | 465 scr_ShowWindow(jid); |
| 24 | 466 } |
| 467 | |
| 143 | 468 // scr_WriteInWindow() |
| 469 // Write some text in the winId window (this usually is a jid). | |
| 470 // Lines are splitted when they are too long to fit in the chat window. | |
| 471 // If this window doesn't exist, it is created. | |
| 184 | 472 void scr_WriteInWindow(const char *winId, const char *text, time_t timestamp, |
| 473 unsigned int prefix_flags, int force_show) | |
| 24 | 474 { |
| 74 | 475 window_entry_t *win_entry; |
| 24 | 476 int dont_show = FALSE; |
| 477 | |
| 74 | 478 // Look for the window entry. |
| 479 win_entry = scr_SearchWindow(winId); | |
| 480 | |
| 481 // Do we have to really show the window? | |
| 24 | 482 if (!chatmode) |
| 483 dont_show = TRUE; | |
| 74 | 484 else if ((!force_show) && ((!currentWindow || (currentWindow != win_entry)))) |
| 24 | 485 dont_show = TRUE; |
| 486 | |
| 74 | 487 // If the window entry doesn't exist yet, let's create it. |
| 488 if (win_entry == NULL) { | |
| 151 | 489 win_entry = scr_CreateBuddyPanel(winId, dont_show); |
| 24 | 490 } |
| 491 | |
| 220 | 492 // The message must be displayed -> update top pointer |
| 493 if (win_entry->cleared) | |
| 494 win_entry->top = g_list_last(win_entry->hbuf); | |
| 495 | |
| 184 | 496 hbuf_add_line(&win_entry->hbuf, text, timestamp, prefix_flags, |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
497 maxX - Roster_Width - PREFIX_WIDTH); |
| 74 | 498 |
| 108 | 499 if (win_entry->cleared) { |
| 220 | 500 win_entry->cleared = FALSE; |
| 501 if (g_list_next(win_entry->top)) | |
| 502 win_entry->top = g_list_next(win_entry->top); | |
| 503 } | |
| 504 | |
| 505 // Make sure the last line appears in the window; update top if necessary | |
| 506 if (win_entry->top) { | |
| 507 int dist; | |
| 508 GList *first = g_list_first(win_entry->hbuf); | |
| 509 dist = g_list_position(first, g_list_last(win_entry->hbuf)) - | |
| 510 g_list_position(first, win_entry->top); | |
| 511 if (dist >= CHAT_WIN_HEIGHT) | |
| 512 win_entry->top = NULL; | |
| 108 | 513 } |
| 514 | |
| 24 | 515 if (!dont_show) { |
| 74 | 516 // Show and refresh the window |
| 517 top_panel(win_entry->panel); | |
| 518 scr_UpdateWindow(win_entry); | |
| 142 | 519 top_panel(inputPanel); |
| 24 | 520 update_panels(); |
| 521 doupdate(); | |
| 513 | 522 } else if (!(prefix_flags & HBB_PREFIX_NOFLAG)) { |
| 148 | 523 roster_msg_setflag(winId, TRUE); |
| 30 | 524 update_roster = TRUE; |
| 24 | 525 } |
| 526 } | |
| 527 | |
| 713 | 528 // scr_UpdateMainStatus() |
| 529 // Redraw the main (bottom) status line. | |
| 530 void scr_UpdateMainStatus(void) | |
| 531 { | |
| 532 const char *sm = jb_getstatusmsg(); | |
| 533 | |
| 534 werase(mainstatusWnd); | |
| 535 mvwprintw(mainstatusWnd, 0, 1, | |
| 536 "[%c] %s", imstatus2char[jb_getstatus()], (sm ? sm : "")); | |
| 537 top_panel(inputPanel); | |
| 538 update_panels(); | |
| 539 doupdate(); | |
| 540 } | |
| 541 | |
| 151 | 542 // scr_DrawMainWindow() |
| 157 | 543 // Set fullinit to TRUE to also create panels. Set it to FALSE for a resize. |
| 151 | 544 // |
| 545 // I think it could be improved a _lot_ but I'm really not an ncurses | |
| 546 // expert... :-\ Mikael. | |
| 547 // | |
| 548 void scr_DrawMainWindow(unsigned int fullinit) | |
| 24 | 549 { |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
550 int requested_size; |
|
518
9480a76471b6
Update Log_Win_Height when refreshing the screen
Mikael Berthe <mikael@lilotux.net>
parents:
515
diff
changeset
|
551 |
|
9480a76471b6
Update Log_Win_Height when refreshing the screen
Mikael Berthe <mikael@lilotux.net>
parents:
515
diff
changeset
|
552 Log_Win_Height = DEFAULT_LOG_WIN_HEIGHT; |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
553 requested_size = settings_opt_get_int("log_win_height"); |
|
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
554 if (requested_size > 0) { |
|
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
555 if (maxY > requested_size + 3) |
|
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
556 Log_Win_Height = requested_size + 2; |
|
518
9480a76471b6
Update Log_Win_Height when refreshing the screen
Mikael Berthe <mikael@lilotux.net>
parents:
515
diff
changeset
|
557 else |
|
9480a76471b6
Update Log_Win_Height when refreshing the screen
Mikael Berthe <mikael@lilotux.net>
parents:
515
diff
changeset
|
558 Log_Win_Height = ((maxY > 5) ? (maxY - 2) : 3); |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
559 } else if (requested_size < 0) { |
|
518
9480a76471b6
Update Log_Win_Height when refreshing the screen
Mikael Berthe <mikael@lilotux.net>
parents:
515
diff
changeset
|
560 Log_Win_Height = 3; |
|
9480a76471b6
Update Log_Win_Height when refreshing the screen
Mikael Berthe <mikael@lilotux.net>
parents:
515
diff
changeset
|
561 } |
|
9480a76471b6
Update Log_Win_Height when refreshing the screen
Mikael Berthe <mikael@lilotux.net>
parents:
515
diff
changeset
|
562 |
|
9480a76471b6
Update Log_Win_Height when refreshing the screen
Mikael Berthe <mikael@lilotux.net>
parents:
515
diff
changeset
|
563 if (maxY < Log_Win_Height+2) { |
|
9480a76471b6
Update Log_Win_Height when refreshing the screen
Mikael Berthe <mikael@lilotux.net>
parents:
515
diff
changeset
|
564 if (maxY < 5) { |
|
9480a76471b6
Update Log_Win_Height when refreshing the screen
Mikael Berthe <mikael@lilotux.net>
parents:
515
diff
changeset
|
565 Log_Win_Height = 3; |
|
9480a76471b6
Update Log_Win_Height when refreshing the screen
Mikael Berthe <mikael@lilotux.net>
parents:
515
diff
changeset
|
566 maxY = Log_Win_Height+2; |
|
9480a76471b6
Update Log_Win_Height when refreshing the screen
Mikael Berthe <mikael@lilotux.net>
parents:
515
diff
changeset
|
567 } else { |
|
9480a76471b6
Update Log_Win_Height when refreshing the screen
Mikael Berthe <mikael@lilotux.net>
parents:
515
diff
changeset
|
568 Log_Win_Height = maxY - 2; |
|
9480a76471b6
Update Log_Win_Height when refreshing the screen
Mikael Berthe <mikael@lilotux.net>
parents:
515
diff
changeset
|
569 } |
|
9480a76471b6
Update Log_Win_Height when refreshing the screen
Mikael Berthe <mikael@lilotux.net>
parents:
515
diff
changeset
|
570 } |
|
9480a76471b6
Update Log_Win_Height when refreshing the screen
Mikael Berthe <mikael@lilotux.net>
parents:
515
diff
changeset
|
571 |
|
707
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
572 if (roster_hidden) { |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
573 Roster_Width = 0; |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
574 } else { |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
575 requested_size = settings_opt_get_int("roster_width"); |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
576 if (requested_size > 1) |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
577 Roster_Width = requested_size; |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
578 else if (requested_size == 1) |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
579 Roster_Width = 2; |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
580 else |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
581 Roster_Width = DEFAULT_ROSTER_WIDTH; |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
582 } |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
583 |
| 157 | 584 if (fullinit) { |
| 585 /* Create windows */ | |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
586 rosterWnd = newwin(CHAT_WIN_HEIGHT, Roster_Width, 0, 0); |
|
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
587 chatWnd = newwin(CHAT_WIN_HEIGHT, maxX - Roster_Width, 0, Roster_Width); |
| 711 | 588 logWnd = newwin(Log_Win_Height-2, maxX, CHAT_WIN_HEIGHT+1, 0); |
| 589 chatstatusWnd = newwin(1, maxX, CHAT_WIN_HEIGHT, 0); | |
| 590 mainstatusWnd = newwin(1, maxX, maxY-2, 0); | |
| 157 | 591 inputWnd = newwin(1, maxX, maxY-1, 0); |
|
358
6e4e667c5571
Fix a segfault when starting mcabber in a really small terminal
Mikael Berthe <mikael@lilotux.net>
parents:
339
diff
changeset
|
592 if (!rosterWnd || !chatWnd || !logWnd || !inputWnd) { |
|
6e4e667c5571
Fix a segfault when starting mcabber in a really small terminal
Mikael Berthe <mikael@lilotux.net>
parents:
339
diff
changeset
|
593 scr_TerminateCurses(); |
|
6e4e667c5571
Fix a segfault when starting mcabber in a really small terminal
Mikael Berthe <mikael@lilotux.net>
parents:
339
diff
changeset
|
594 fprintf(stderr, "Cannot create windows!\n"); |
|
6e4e667c5571
Fix a segfault when starting mcabber in a really small terminal
Mikael Berthe <mikael@lilotux.net>
parents:
339
diff
changeset
|
595 exit(EXIT_FAILURE); |
|
6e4e667c5571
Fix a segfault when starting mcabber in a really small terminal
Mikael Berthe <mikael@lilotux.net>
parents:
339
diff
changeset
|
596 } |
| 168 | 597 wbkgd(rosterWnd, COLOR_PAIR(COLOR_GENERAL)); |
| 598 wbkgd(chatWnd, COLOR_PAIR(COLOR_GENERAL)); | |
| 599 wbkgd(logWnd, COLOR_PAIR(COLOR_GENERAL)); | |
| 711 | 600 wbkgd(chatstatusWnd, COLOR_PAIR(COLOR_STATUS)); |
| 601 wbkgd(mainstatusWnd, COLOR_PAIR(COLOR_STATUS)); | |
| 157 | 602 } else { |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
603 /* Resize/move windows */ |
|
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
604 wresize(rosterWnd, CHAT_WIN_HEIGHT, Roster_Width); |
|
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
605 wresize(chatWnd, CHAT_WIN_HEIGHT, maxX - Roster_Width); |
|
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
606 mvwin(chatWnd, 0, Roster_Width); |
| 157 | 607 |
| 711 | 608 wresize(logWnd, Log_Win_Height-2, maxX); |
| 609 mvwin(logWnd, CHAT_WIN_HEIGHT+1, 0); | |
| 157 | 610 |
| 711 | 611 // Resize & move chat status window |
| 612 wresize(chatstatusWnd, 1, maxX); | |
| 613 mvwin(chatstatusWnd, CHAT_WIN_HEIGHT, 0); | |
| 614 // Resize & move main status window | |
| 615 wresize(mainstatusWnd, 1, maxX); | |
| 616 mvwin(mainstatusWnd, maxY-2, 0); | |
| 617 // Resize & move input line window | |
| 157 | 618 wresize(inputWnd, 1, maxX); |
| 619 mvwin(inputWnd, maxY-1, 0); | |
| 168 | 620 |
| 621 werase(chatWnd); | |
| 157 | 622 } |
| 151 | 623 |
| 624 /* Draw/init windows */ | |
| 625 | |
|
679
5933a8036672
Remove "This is the status window" message
Mikael Berthe <mikael@lilotux.net>
parents:
675
diff
changeset
|
626 mvwprintw(chatWnd, 0, 0, "Thanks for using mcabber.\n"); |
|
5933a8036672
Remove "This is the status window" message
Mikael Berthe <mikael@lilotux.net>
parents:
675
diff
changeset
|
627 mvwprintw(chatWnd, 1, 0, "http://www.lilotux.net/~mikael/mcabber/"); |
| 24 | 628 |
| 157 | 629 // Auto-scrolling in log window |
| 74 | 630 scrollok(logWnd, TRUE); |
| 24 | 631 |
| 632 | |
| 151 | 633 if (fullinit) { |
| 157 | 634 // Enable keypad (+ special keys) |
| 635 keypad(inputWnd, TRUE); | |
|
382
4c6e8392e465
Use nodelay() instead of halfdelay()
Mikael Berthe <mikael@lilotux.net>
parents:
374
diff
changeset
|
636 nodelay(inputWnd, TRUE); |
| 157 | 637 |
| 151 | 638 // Create panels |
| 639 rosterPanel = new_panel(rosterWnd); | |
| 640 chatPanel = new_panel(chatWnd); | |
| 641 logPanel = new_panel(logWnd); | |
| 711 | 642 chatstatusPanel = new_panel(chatstatusWnd); |
| 643 mainstatusPanel = new_panel(mainstatusWnd); | |
| 151 | 644 inputPanel = new_panel(inputWnd); |
| 232 | 645 |
| 646 if (utf8_mode) | |
|
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
647 scr_LogPrint(LPRINT_NORMAL, "WARNING: UTF-8 not yet supported!"); |
| 157 | 648 } else { |
| 649 // Update panels | |
| 650 replace_panel(rosterPanel, rosterWnd); | |
| 651 replace_panel(chatPanel, chatWnd); | |
| 652 replace_panel(logPanel, logWnd); | |
| 711 | 653 replace_panel(chatstatusPanel, chatstatusWnd); |
| 654 replace_panel(mainstatusPanel, mainstatusWnd); | |
| 157 | 655 replace_panel(inputPanel, inputWnd); |
| 151 | 656 } |
| 657 | |
| 713 | 658 scr_UpdateMainStatus(); |
| 151 | 659 // We'll need to redraw the roster |
| 149 | 660 update_roster = TRUE; |
| 24 | 661 return; |
| 662 } | |
| 663 | |
| 151 | 664 // scr_Resize() |
| 665 // Function called when the window is resized. | |
| 157 | 666 // - Resize windows |
| 151 | 667 // - Rewrap lines in each buddy buffer |
| 668 void scr_Resize() | |
| 669 { | |
| 670 struct list_head *pos, *n; | |
| 671 window_entry_t *search_entry; | |
| 672 int x, y, lines, cols; | |
| 673 | |
| 674 // First, update the global variables | |
| 675 getmaxyx(stdscr, maxY, maxX); | |
|
518
9480a76471b6
Update Log_Win_Height when refreshing the screen
Mikael Berthe <mikael@lilotux.net>
parents:
515
diff
changeset
|
676 // scr_DrawMainWindow() will take care of maxY and Log_Win_Height |
|
9480a76471b6
Update Log_Win_Height when refreshing the screen
Mikael Berthe <mikael@lilotux.net>
parents:
515
diff
changeset
|
677 |
| 151 | 678 // Make sure the cursor stays inside the window |
| 679 check_offset(0); | |
| 680 | |
| 157 | 681 // Resize windows and update panels |
| 151 | 682 scr_DrawMainWindow(FALSE); |
| 683 | |
| 684 // Resize all buddy windows | |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
685 x = Roster_Width; |
| 151 | 686 y = 0; |
| 687 lines = CHAT_WIN_HEIGHT; | |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
688 cols = maxX - Roster_Width; |
|
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
689 if (cols < 1) cols = 1; |
| 151 | 690 |
| 691 list_for_each_safe(pos, n, &window_list) { | |
| 692 search_entry = window_entry(pos); | |
| 693 if (search_entry->win) { | |
| 189 | 694 GList *rescue_top; |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
695 // Resize/move buddy window |
| 157 | 696 wresize(search_entry->win, lines, cols); |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
697 mvwin(search_entry->win, 0, Roster_Width); |
| 168 | 698 werase(search_entry->win); |
| 151 | 699 // If a panel exists, replace the old window with the new |
| 700 if (search_entry->panel) { | |
| 701 replace_panel(search_entry->panel, search_entry->win); | |
| 702 } | |
| 703 // Redo line wrapping | |
| 189 | 704 rescue_top = hbuf_previous_persistent(search_entry->top); |
| 151 | 705 hbuf_rebuild(&search_entry->hbuf, |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
706 maxX - Roster_Width - PREFIX_WIDTH); |
|
388
f211238d5812
Ctrl-l does a full refresh
Mikael Berthe <mikael@lilotux.net>
parents:
384
diff
changeset
|
707 if (g_list_position(g_list_first(search_entry->hbuf), |
|
f211238d5812
Ctrl-l does a full refresh
Mikael Berthe <mikael@lilotux.net>
parents:
384
diff
changeset
|
708 search_entry->top) == -1) { |
| 189 | 709 search_entry->top = rescue_top; |
|
388
f211238d5812
Ctrl-l does a full refresh
Mikael Berthe <mikael@lilotux.net>
parents:
384
diff
changeset
|
710 } |
| 151 | 711 } |
| 712 } | |
| 713 | |
| 714 // Refresh current buddy window | |
| 157 | 715 if (chatmode) |
| 151 | 716 scr_ShowBuddyWindow(); |
| 717 } | |
| 718 | |
| 713 | 719 // update_chat_status_window() |
| 720 // Redraw the buddy status bar. | |
| 721 static void update_chat_status_window(void) | |
| 722 { | |
| 723 unsigned short btype, isgrp, ismuc; | |
| 724 const char *fullname; | |
| 725 const char *msg = NULL; | |
| 726 char status; | |
| 727 char *buf; | |
| 728 | |
|
714
4bcd48f6ca5f
Display group name in the chat status line
Mikael Berthe <mikael@lilotux.net>
parents:
713
diff
changeset
|
729 fullname = buddy_getname(BUDDATA(current_buddy)); |
| 713 | 730 btype = buddy_gettype(BUDDATA(current_buddy)); |
| 731 | |
| 732 isgrp = btype & ROSTER_TYPE_GROUP; | |
| 733 ismuc = btype & ROSTER_TYPE_ROOM; | |
| 734 | |
| 735 // Clear the line | |
| 736 werase(chatstatusWnd); | |
| 737 | |
|
714
4bcd48f6ca5f
Display group name in the chat status line
Mikael Berthe <mikael@lilotux.net>
parents:
713
diff
changeset
|
738 if (isgrp) { |
|
4bcd48f6ca5f
Display group name in the chat status line
Mikael Berthe <mikael@lilotux.net>
parents:
713
diff
changeset
|
739 mvwprintw(chatstatusWnd, 0, 5, "Group: %s", fullname); |
|
4bcd48f6ca5f
Display group name in the chat status line
Mikael Berthe <mikael@lilotux.net>
parents:
713
diff
changeset
|
740 return; |
|
4bcd48f6ca5f
Display group name in the chat status line
Mikael Berthe <mikael@lilotux.net>
parents:
713
diff
changeset
|
741 } |
| 713 | 742 |
| 743 status = '?'; | |
| 744 | |
| 745 if (ismuc) { | |
| 746 if (buddy_getinsideroom(BUDDATA(current_buddy))) | |
| 747 status = 'C'; | |
| 748 else | |
| 749 status = 'x'; | |
| 750 } else if (jb_getstatus() != offline) { | |
| 751 enum imstatus budstate; | |
| 752 budstate = buddy_getstatus(BUDDATA(current_buddy), NULL); | |
| 753 if (budstate >= 0 && budstate < imstatus_size) | |
| 754 status = imstatus2char[budstate]; | |
| 755 } | |
| 756 | |
| 757 // No status message for groups & MUC rooms | |
| 758 if (!isgrp && !ismuc) { | |
| 759 GSList *resources = buddy_getresources(BUDDATA(current_buddy)); | |
| 760 if (resources) | |
| 761 msg = buddy_getstatusmsg(BUDDATA(current_buddy), resources->data); | |
| 762 } | |
| 763 if (!msg) | |
| 764 msg = ""; | |
| 765 | |
| 766 buf = g_strdup_printf("[%c] Buddy: %s -- %s", status, fullname, msg); | |
| 767 replace_nl_with_dots(buf); | |
| 768 mvwprintw(chatstatusWnd, 0, 1, "%s", buf); | |
| 769 g_free(buf); | |
| 770 } | |
| 771 | |
| 143 | 772 // scr_DrawRoster() |
|
328
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
773 // Display the buddylist (not really the roster) on the screen |
| 81 | 774 void scr_DrawRoster(void) |
| 24 | 775 { |
| 81 | 776 static guint offset = 0; |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
777 char *name, *rline; |
| 81 | 778 int maxx, maxy; |
| 779 GList *buddy; | |
| 780 int i, n; | |
| 781 int rOffset; | |
| 713 | 782 int cursor_backup; |
| 783 char status, pending; | |
| 164 | 784 enum imstatus currentstatus = jb_getstatus(); |
| 81 | 785 |
| 123 | 786 // We can reset update_roster |
| 787 update_roster = FALSE; | |
| 788 | |
| 81 | 789 getmaxyx(rosterWnd, maxy, maxx); |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
790 maxx--; // Last char is for vertical border |
| 81 | 791 |
| 713 | 792 cursor_backup = curs_set(0); |
| 793 | |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
794 // Cleanup of roster window |
| 168 | 795 werase(rosterWnd); |
| 81 | 796 |
|
707
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
797 if (Roster_Width) { |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
798 // Redraw the vertical line (not very good...) |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
799 wattrset(rosterWnd, COLOR_PAIR(COLOR_GENERAL)); |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
800 for (i=0 ; i < CHAT_WIN_HEIGHT ; i++) |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
801 mvwaddch(rosterWnd, i, Roster_Width-1, ACS_VLINE); |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
802 } |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
803 |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
804 if (!buddylist) |
| 81 | 805 offset = 0; |
| 713 | 806 else |
| 807 update_chat_status_window(); | |
|
707
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
808 |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
809 // Leave now if buddylist is empty or the roster is hidden |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
810 if (!buddylist || !Roster_Width) { |
| 123 | 811 update_panels(); |
| 812 doupdate(); | |
| 713 | 813 curs_set(cursor_backup); |
| 81 | 814 return; |
| 815 } | |
| 816 | |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
817 name = g_new0(char, Roster_Width); |
|
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
818 |
| 84 | 819 // Update offset if necessary |
|
680
1f8987e0e56c
Try to display as many buddylist items as possible
Mikael Berthe <mikael@lilotux.net>
parents:
679
diff
changeset
|
820 // a) Try to show as many buddylist items as possible |
|
1f8987e0e56c
Try to display as many buddylist items as possible
Mikael Berthe <mikael@lilotux.net>
parents:
679
diff
changeset
|
821 i = g_list_length(buddylist) - maxy; |
|
682
f3945593432e
Small fix in scr_DrawRoster()
Mikael Berthe <mikael@lilotux.net>
parents:
680
diff
changeset
|
822 if (i < 0) |
|
f3945593432e
Small fix in scr_DrawRoster()
Mikael Berthe <mikael@lilotux.net>
parents:
680
diff
changeset
|
823 i = 0; |
|
f3945593432e
Small fix in scr_DrawRoster()
Mikael Berthe <mikael@lilotux.net>
parents:
680
diff
changeset
|
824 if (i < offset) |
|
680
1f8987e0e56c
Try to display as many buddylist items as possible
Mikael Berthe <mikael@lilotux.net>
parents:
679
diff
changeset
|
825 offset = i; |
|
1f8987e0e56c
Try to display as many buddylist items as possible
Mikael Berthe <mikael@lilotux.net>
parents:
679
diff
changeset
|
826 // b) Make sure the current_buddy is visible |
| 84 | 827 i = g_list_position(buddylist, current_buddy); |
| 828 if (i == -1) { // This is bad | |
|
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
829 scr_LogPrint(LPRINT_NORMAL, "Doh! Can't find current selected buddy!!"); |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
830 g_free(name); |
| 713 | 831 curs_set(cursor_backup); |
| 84 | 832 return; |
| 833 } else if (i < offset) { | |
| 834 offset = i; | |
| 835 } else if (i+1 > offset + maxy) { | |
| 836 offset = i + 1 - maxy; | |
| 837 } | |
| 81 | 838 |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
839 rline = g_new0(char, Roster_Width+1); |
|
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
840 |
| 81 | 841 buddy = buddylist; |
| 842 rOffset = offset; | |
| 843 | |
| 84 | 844 for (i=0; i<maxy && buddy; buddy = g_list_next(buddy)) { |
| 713 | 845 unsigned short bflags, btype, ismsg, isgrp, ismuc, ishid; |
| 846 | |
| 847 bflags = buddy_getflags(BUDDATA(buddy)); | |
| 848 btype = buddy_gettype(BUDDATA(buddy)); | |
| 849 | |
| 850 ismsg = bflags & ROSTER_FLAG_MSG; | |
| 851 ishid = bflags & ROSTER_FLAG_HIDE; | |
| 852 isgrp = btype & ROSTER_TYPE_GROUP; | |
| 853 ismuc = btype & ROSTER_TYPE_ROOM; | |
| 81 | 854 |
| 855 if (rOffset > 0) { | |
| 856 rOffset--; | |
| 857 continue; | |
| 858 } | |
| 859 | |
| 713 | 860 status = '?'; |
| 861 pending = ' '; | |
| 862 | |
| 149 | 863 // Display message notice if there is a message flag, but not |
| 864 // for unfolded groups. | |
| 865 if (ismsg && (!isgrp || ishid)) { | |
| 81 | 866 pending = '#'; |
| 867 } | |
| 868 | |
| 713 | 869 if (ismuc) { |
| 870 if (buddy_getinsideroom(BUDDATA(buddy))) | |
| 871 status = 'C'; | |
| 872 else | |
| 873 status = 'x'; | |
| 874 } else if (currentstatus != offline) { | |
| 875 enum imstatus budstate; | |
| 876 budstate = buddy_getstatus(BUDDATA(buddy), NULL); | |
| 877 if (budstate >= 0 && budstate < imstatus_size) | |
| 878 status = imstatus2char[budstate]; | |
| 879 } | |
| 81 | 880 if (buddy == current_buddy) { |
| 712 | 881 wattrset(rosterWnd, COLOR_PAIR(COLOR_ROSTERSEL)); |
| 81 | 882 // The 3 following lines aim to color the whole line |
| 883 wmove(rosterWnd, i, 0); | |
| 884 for (n = 0; n < maxx; n++) | |
| 885 waddch(rosterWnd, ' '); | |
| 886 } else { | |
| 149 | 887 if (pending == '#') |
| 712 | 888 wattrset(rosterWnd, COLOR_PAIR(COLOR_ROSTERNMSG)); |
| 139 | 889 else |
| 712 | 890 wattrset(rosterWnd, COLOR_PAIR(COLOR_ROSTER)); |
| 81 | 891 } |
| 892 | |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
893 if (Roster_Width > 7) |
|
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
894 strncpy(name, buddy_getname(BUDDATA(buddy)), Roster_Width-7); |
|
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
895 else |
|
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
896 name[0] = 0; |
|
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
897 |
| 149 | 898 if (isgrp) { |
| 133 | 899 char *sep; |
| 149 | 900 if (ishid) |
| 133 | 901 sep = "+++"; |
| 902 else | |
| 903 sep = "---"; | |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
904 snprintf(rline, Roster_Width, " %c%s %s", pending, sep, name); |
|
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
905 } else { |
|
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
906 snprintf(rline, Roster_Width, " %c[%c] %s", pending, status, name); |
| 133 | 907 } |
| 84 | 908 |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
909 mvwprintw(rosterWnd, i, 0, "%s", rline); |
| 84 | 910 i++; |
| 81 | 911 } |
| 912 | |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
913 g_free(rline); |
|
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
914 g_free(name); |
| 142 | 915 top_panel(inputPanel); |
| 81 | 916 update_panels(); |
| 917 doupdate(); | |
| 713 | 918 curs_set(cursor_backup); |
| 24 | 919 } |
| 920 | |
|
707
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
921 // scr_RosterVisibility(status) |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
922 // Set the roster visibility: |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
923 // status=1 Show roster |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
924 // status=0 Hide roster |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
925 // status=-1 Toggle roster status |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
926 void scr_RosterVisibility(int status) |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
927 { |
|
708
ed326697e4ed
scr_RosterVisibility(): do not refresh when it is not needed
Mikael Berthe <mikael@lilotux.net>
parents:
707
diff
changeset
|
928 int old_roster_status = roster_hidden; |
|
ed326697e4ed
scr_RosterVisibility(): do not refresh when it is not needed
Mikael Berthe <mikael@lilotux.net>
parents:
707
diff
changeset
|
929 |
|
707
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
930 if (status > 0) |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
931 roster_hidden = FALSE; |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
932 else if (status == 0) |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
933 roster_hidden = TRUE; |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
934 else |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
935 roster_hidden = !roster_hidden; |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
936 |
|
708
ed326697e4ed
scr_RosterVisibility(): do not refresh when it is not needed
Mikael Berthe <mikael@lilotux.net>
parents:
707
diff
changeset
|
937 if (roster_hidden != old_roster_status) { |
|
709
5aa66101807b
Leave full-width mode automatically under some conditions
Mikael Berthe <mikael@lilotux.net>
parents:
708
diff
changeset
|
938 if (roster_hidden) { |
|
5aa66101807b
Leave full-width mode automatically under some conditions
Mikael Berthe <mikael@lilotux.net>
parents:
708
diff
changeset
|
939 // Enter chat mode |
|
5aa66101807b
Leave full-width mode automatically under some conditions
Mikael Berthe <mikael@lilotux.net>
parents:
708
diff
changeset
|
940 scr_set_chatmode(TRUE); |
|
5aa66101807b
Leave full-width mode automatically under some conditions
Mikael Berthe <mikael@lilotux.net>
parents:
708
diff
changeset
|
941 scr_ShowBuddyWindow(); |
|
5aa66101807b
Leave full-width mode automatically under some conditions
Mikael Berthe <mikael@lilotux.net>
parents:
708
diff
changeset
|
942 } |
|
708
ed326697e4ed
scr_RosterVisibility(): do not refresh when it is not needed
Mikael Berthe <mikael@lilotux.net>
parents:
707
diff
changeset
|
943 // Recalculate windows size and redraw |
|
ed326697e4ed
scr_RosterVisibility(): do not refresh when it is not needed
Mikael Berthe <mikael@lilotux.net>
parents:
707
diff
changeset
|
944 scr_Resize(); |
|
ed326697e4ed
scr_RosterVisibility(): do not refresh when it is not needed
Mikael Berthe <mikael@lilotux.net>
parents:
707
diff
changeset
|
945 redrawwin(stdscr); |
|
ed326697e4ed
scr_RosterVisibility(): do not refresh when it is not needed
Mikael Berthe <mikael@lilotux.net>
parents:
707
diff
changeset
|
946 } |
|
707
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
947 } |
|
b26a0bde4cdb
Add /roster hide|show|toggle
Mikael Berthe <mikael@lilotux.net>
parents:
701
diff
changeset
|
948 |
| 480 | 949 inline void scr_WriteMessage(const char *jid, const char *text, |
| 950 time_t timestamp, guint prefix_flags) | |
| 24 | 951 { |
| 184 | 952 if (!timestamp) timestamp = time(NULL); |
| 953 | |
| 954 scr_WriteInWindow(jid, text, timestamp, prefix_flags, FALSE); | |
| 47 | 955 } |
| 956 | |
| 190 | 957 // If prefix is NULL, HBB_PREFIX_IN is supposed. |
| 184 | 958 void scr_WriteIncomingMessage(const char *jidfrom, const char *text, |
| 190 | 959 time_t timestamp, guint prefix) |
| 47 | 960 { |
| 513 | 961 if (!(prefix & ~HBB_PREFIX_NOFLAG)) |
| 962 prefix |= HBB_PREFIX_IN; | |
| 75 | 963 // FIXME expand tabs / filter out special chars... |
| 190 | 964 scr_WriteMessage(jidfrom, text, timestamp, prefix); |
| 24 | 965 update_panels(); |
| 966 doupdate(); | |
| 967 } | |
| 968 | |
| 50 | 969 void scr_WriteOutgoingMessage(const char *jidto, const char *text) |
| 47 | 970 { |
| 184 | 971 scr_WriteMessage(jidto, text, 0, HBB_PREFIX_OUT); |
| 47 | 972 scr_ShowWindow(jidto); |
| 973 } | |
| 974 | |
|
373
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
975 void inline set_autoaway(bool setaway) |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
976 { |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
977 static enum imstatus oldstatus; |
| 521 | 978 static char *oldmsg; |
|
373
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
979 Autoaway = setaway; |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
980 |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
981 if (setaway) { |
| 521 | 982 const char *msg, *prevmsg; |
|
373
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
983 oldstatus = jb_getstatus(); |
| 521 | 984 if (oldmsg) { |
| 985 g_free(oldmsg); | |
| 986 oldmsg = NULL; | |
| 987 } | |
| 988 prevmsg = jb_getstatusmsg(); | |
|
373
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
989 msg = settings_opt_get("message_autoaway"); |
| 521 | 990 if (!msg) |
| 991 msg = prevmsg; | |
| 992 if (prevmsg) | |
| 993 oldmsg = g_strdup(prevmsg); | |
| 444 | 994 jb_setstatus(away, NULL, msg); |
|
373
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
995 } else { |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
996 // Back |
| 521 | 997 jb_setstatus(oldstatus, NULL, (oldmsg ? oldmsg : "")); |
| 998 if (oldmsg) { | |
| 999 g_free(oldmsg); | |
| 1000 oldmsg = NULL; | |
| 1001 } | |
|
373
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1002 } |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1003 } |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1004 |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1005 // Check if we should enter/leave automatic away status |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1006 void scr_CheckAutoAway(bool activity) |
| 24 | 1007 { |
|
373
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1008 static time_t LastActivity; |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1009 enum imstatus cur_st; |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1010 unsigned int autoaway_timeout = settings_opt_get_int("autoaway"); |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1011 |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1012 if (Autoaway && activity) set_autoaway(FALSE); |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1013 if (!autoaway_timeout) return; |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1014 if (!LastActivity || activity) time(&LastActivity); |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1015 |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1016 cur_st = jb_getstatus(); |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1017 // Auto-away is disabled for the following states |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1018 if ((cur_st != available) && (cur_st != freeforchat)) |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1019 return; |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1020 |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1021 if (!activity) { |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1022 time_t now; |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1023 time(&now); |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1024 if (!Autoaway && (now > LastActivity + autoaway_timeout)) |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1025 set_autoaway(TRUE); |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1026 } |
| 24 | 1027 } |
| 1028 | |
|
328
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1029 // set_current_buddy(newbuddy) |
|
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1030 // Set the current_buddy to newbuddy (if not NULL) |
|
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1031 // Lock the newbuddy, and unlock the previous current_buddy |
|
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1032 static void set_current_buddy(GList *newbuddy) |
| 24 | 1033 { |
|
328
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1034 enum imstatus prev_st = imstatus_size; |
|
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1035 /* prev_st initialized to imstatus_size, which is used as "undef" value. |
|
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1036 * We are sure prev_st will get a different status value after the |
|
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1037 * buddy_getstatus() call. |
|
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1038 */ |
|
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1039 |
|
329
7c53bf62a2a2
scr_RosterUnreadMessage() uses set_current_buddy()
Mikael Berthe <mikael@lilotux.net>
parents:
328
diff
changeset
|
1040 if (!current_buddy || !newbuddy) return; |
|
7c53bf62a2a2
scr_RosterUnreadMessage() uses set_current_buddy()
Mikael Berthe <mikael@lilotux.net>
parents:
328
diff
changeset
|
1041 if (newbuddy == current_buddy) return; |
| 24 | 1042 |
|
438
b44be19d6229
Handle multiple resources for the same buddy
Mikael Berthe <mikael@lilotux.net>
parents:
419
diff
changeset
|
1043 prev_st = buddy_getstatus(BUDDATA(current_buddy), NULL); |
|
328
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1044 buddy_setflags(BUDDATA(current_buddy), ROSTER_FLAG_LOCK, FALSE); |
| 330 | 1045 if (chatmode) |
| 1046 alternate_buddy = current_buddy; | |
|
328
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1047 current_buddy = newbuddy; |
|
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1048 // Lock the buddy in the buddylist if we're in chat mode |
|
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1049 if (chatmode) |
|
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1050 buddy_setflags(BUDDATA(current_buddy), ROSTER_FLAG_LOCK, TRUE); |
|
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1051 // We should rebuild the buddylist but not everytime |
|
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1052 // Here we check if we were locking a buddy who is actually offline, |
|
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1053 // and hide_offline_buddies is TRUE. In which case we need to rebuild. |
|
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1054 if (prev_st == offline && buddylist_get_hide_offline_buddies()) |
|
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1055 buddylist_build(); |
|
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1056 update_roster = TRUE; |
| 24 | 1057 } |
| 1058 | |
| 143 | 1059 // scr_RosterTop() |
| 1060 // Go to the first buddy in the buddylist | |
| 105 | 1061 void scr_RosterTop(void) |
| 104 | 1062 { |
|
328
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1063 set_current_buddy(buddylist); |
| 104 | 1064 if (chatmode) |
| 1065 scr_ShowBuddyWindow(); | |
| 1066 } | |
| 1067 | |
| 143 | 1068 // scr_RosterBottom() |
| 1069 // Go to the last buddy in the buddylist | |
| 105 | 1070 void scr_RosterBottom(void) |
| 104 | 1071 { |
|
328
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1072 set_current_buddy(g_list_last(buddylist)); |
| 104 | 1073 if (chatmode) |
| 1074 scr_ShowBuddyWindow(); | |
| 1075 } | |
| 1076 | |
| 143 | 1077 // scr_RosterUp() |
| 1078 // Go to the previous buddy in the buddylist | |
| 105 | 1079 void scr_RosterUp(void) |
| 81 | 1080 { |
|
328
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1081 set_current_buddy(g_list_previous(current_buddy)); |
| 104 | 1082 if (chatmode) |
| 1083 scr_ShowBuddyWindow(); | |
| 81 | 1084 } |
| 1085 | |
| 143 | 1086 // scr_RosterDown() |
| 1087 // Go to the next buddy in the buddylist | |
| 105 | 1088 void scr_RosterDown(void) |
| 81 | 1089 { |
|
328
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1090 set_current_buddy(g_list_next(current_buddy)); |
| 104 | 1091 if (chatmode) |
| 1092 scr_ShowBuddyWindow(); | |
| 81 | 1093 } |
| 1094 | |
| 265 | 1095 // scr_RosterSearch(str) |
| 1096 // Look forward for a buddy with jid/name containing str. | |
| 1097 void scr_RosterSearch(char *str) | |
| 1098 { | |
|
328
83d129adde03
Add set_current_buddy() function, to reduce code duplication
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
1099 set_current_buddy(buddy_search(str)); |
| 265 | 1100 if (chatmode) |
| 1101 scr_ShowBuddyWindow(); | |
| 1102 } | |
| 1103 | |
| 480 | 1104 // scr_RosterJumpJid(jid) |
| 1105 // Jump to buddy jid. | |
| 1106 // NOTE: With this function, the buddy is added to the roster if doesn't exist. | |
| 1107 void scr_RosterJumpJid(char *barejid) | |
| 1108 { | |
| 1109 GSList *roster_elt; | |
| 1110 // Look for an existing buddy | |
| 1111 roster_elt = roster_find(barejid, jidsearch, | |
| 1112 ROSTER_TYPE_USER|ROSTER_TYPE_AGENT|ROSTER_TYPE_ROOM); | |
| 1113 // Create it if necessary | |
| 1114 if (!roster_elt) | |
| 603 | 1115 roster_elt = roster_add_user(barejid, NULL, NULL, ROSTER_TYPE_USER, |
| 1116 sub_none); | |
| 480 | 1117 // Set a lock to see it in the buddylist |
| 1118 buddy_setflags(BUDDATA(roster_elt), ROSTER_FLAG_LOCK, TRUE); | |
| 1119 buddylist_build(); | |
| 1120 // Jump to the buddy | |
| 1121 set_current_buddy(buddy_search_jid(barejid)); | |
| 1122 if (chatmode) | |
| 1123 scr_ShowBuddyWindow(); | |
| 1124 } | |
| 1125 | |
| 236 | 1126 // scr_RosterUnreadMessage(next) |
| 1127 // Go to a new message. If next is not null, try to go to the next new | |
| 1128 // message. If it is not possible or if next is NULL, go to the first new | |
| 1129 // message from unread_list. | |
| 1130 void scr_RosterUnreadMessage(int next) | |
| 1131 { | |
|
329
7c53bf62a2a2
scr_RosterUnreadMessage() uses set_current_buddy()
Mikael Berthe <mikael@lilotux.net>
parents:
328
diff
changeset
|
1132 gpointer unread_ptr; |
|
7c53bf62a2a2
scr_RosterUnreadMessage() uses set_current_buddy()
Mikael Berthe <mikael@lilotux.net>
parents:
328
diff
changeset
|
1133 gpointer refbuddata; |
|
7c53bf62a2a2
scr_RosterUnreadMessage() uses set_current_buddy()
Mikael Berthe <mikael@lilotux.net>
parents:
328
diff
changeset
|
1134 gpointer ngroup; |
|
7c53bf62a2a2
scr_RosterUnreadMessage() uses set_current_buddy()
Mikael Berthe <mikael@lilotux.net>
parents:
328
diff
changeset
|
1135 GList *nbuddy; |
| 236 | 1136 |
|
329
7c53bf62a2a2
scr_RosterUnreadMessage() uses set_current_buddy()
Mikael Berthe <mikael@lilotux.net>
parents:
328
diff
changeset
|
1137 if (!current_buddy) return; |
| 236 | 1138 |
|
329
7c53bf62a2a2
scr_RosterUnreadMessage() uses set_current_buddy()
Mikael Berthe <mikael@lilotux.net>
parents:
328
diff
changeset
|
1139 if (next) refbuddata = BUDDATA(current_buddy); |
|
7c53bf62a2a2
scr_RosterUnreadMessage() uses set_current_buddy()
Mikael Berthe <mikael@lilotux.net>
parents:
328
diff
changeset
|
1140 else refbuddata = NULL; |
| 236 | 1141 |
|
329
7c53bf62a2a2
scr_RosterUnreadMessage() uses set_current_buddy()
Mikael Berthe <mikael@lilotux.net>
parents:
328
diff
changeset
|
1142 unread_ptr = unread_msg(refbuddata); |
|
7c53bf62a2a2
scr_RosterUnreadMessage() uses set_current_buddy()
Mikael Berthe <mikael@lilotux.net>
parents:
328
diff
changeset
|
1143 if (!unread_ptr) return; |
| 236 | 1144 |
|
329
7c53bf62a2a2
scr_RosterUnreadMessage() uses set_current_buddy()
Mikael Berthe <mikael@lilotux.net>
parents:
328
diff
changeset
|
1145 // If buddy is in a folded group, we need to expand it |
|
7c53bf62a2a2
scr_RosterUnreadMessage() uses set_current_buddy()
Mikael Berthe <mikael@lilotux.net>
parents:
328
diff
changeset
|
1146 ngroup = buddy_getgroup(unread_ptr); |
|
7c53bf62a2a2
scr_RosterUnreadMessage() uses set_current_buddy()
Mikael Berthe <mikael@lilotux.net>
parents:
328
diff
changeset
|
1147 if (buddy_getflags(ngroup) & ROSTER_FLAG_HIDE) { |
|
7c53bf62a2a2
scr_RosterUnreadMessage() uses set_current_buddy()
Mikael Berthe <mikael@lilotux.net>
parents:
328
diff
changeset
|
1148 buddy_setflags(ngroup, ROSTER_FLAG_HIDE, FALSE); |
|
7c53bf62a2a2
scr_RosterUnreadMessage() uses set_current_buddy()
Mikael Berthe <mikael@lilotux.net>
parents:
328
diff
changeset
|
1149 buddylist_build(); |
|
7c53bf62a2a2
scr_RosterUnreadMessage() uses set_current_buddy()
Mikael Berthe <mikael@lilotux.net>
parents:
328
diff
changeset
|
1150 } |
| 236 | 1151 |
|
329
7c53bf62a2a2
scr_RosterUnreadMessage() uses set_current_buddy()
Mikael Berthe <mikael@lilotux.net>
parents:
328
diff
changeset
|
1152 nbuddy = g_list_find(buddylist, unread_ptr); |
|
7c53bf62a2a2
scr_RosterUnreadMessage() uses set_current_buddy()
Mikael Berthe <mikael@lilotux.net>
parents:
328
diff
changeset
|
1153 if (nbuddy) { |
|
7c53bf62a2a2
scr_RosterUnreadMessage() uses set_current_buddy()
Mikael Berthe <mikael@lilotux.net>
parents:
328
diff
changeset
|
1154 set_current_buddy(nbuddy); |
|
7c53bf62a2a2
scr_RosterUnreadMessage() uses set_current_buddy()
Mikael Berthe <mikael@lilotux.net>
parents:
328
diff
changeset
|
1155 if (chatmode) scr_ShowBuddyWindow(); |
|
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
1156 } else |
|
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
1157 scr_LogPrint(LPRINT_LOGNORM, "Error: nbuddy == NULL"); // should not happen |
| 236 | 1158 } |
| 1159 | |
| 330 | 1160 // scr_RosterJumpAlternate() |
| 1161 // Try to jump to alternate (== previous) buddy | |
| 1162 void scr_RosterJumpAlternate(void) | |
| 105 | 1163 { |
| 330 | 1164 if (!alternate_buddy || g_list_position(buddylist, alternate_buddy) == -1) |
| 1165 return; | |
| 1166 set_current_buddy(alternate_buddy); | |
| 1167 if (chatmode) | |
| 1168 scr_ShowBuddyWindow(); | |
| 1169 } | |
| 1170 | |
|
369
499170ed71c9
Rename some buffer commands, for homogeneity
Mikael Berthe <mikael@lilotux.net>
parents:
365
diff
changeset
|
1171 // scr_BufferScrollUpDown() |
|
508
5a2132ba2220
Add "/buffer up" and "/buffer down"
Mikael Berthe <mikael@lilotux.net>
parents:
503
diff
changeset
|
1172 // Scroll up/down the current buddy window, |
|
5a2132ba2220
Add "/buffer up" and "/buffer down"
Mikael Berthe <mikael@lilotux.net>
parents:
503
diff
changeset
|
1173 // - half a screen if nblines is 0, |
|
5a2132ba2220
Add "/buffer up" and "/buffer down"
Mikael Berthe <mikael@lilotux.net>
parents:
503
diff
changeset
|
1174 // - up if updown == -1, down if updown == 1 |
|
5a2132ba2220
Add "/buffer up" and "/buffer down"
Mikael Berthe <mikael@lilotux.net>
parents:
503
diff
changeset
|
1175 void scr_BufferScrollUpDown(int updown, unsigned int nblines) |
| 105 | 1176 { |
| 1177 window_entry_t *win_entry; | |
|
508
5a2132ba2220
Add "/buffer up" and "/buffer down"
Mikael Berthe <mikael@lilotux.net>
parents:
503
diff
changeset
|
1178 int n, nbl; |
| 105 | 1179 GList *hbuf_top; |
| 1180 | |
| 1181 // Get win_entry | |
|
361
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1182 if (!current_buddy) return; |
|
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1183 win_entry = scr_SearchWindow(CURRENT_JID); |
|
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1184 if (!win_entry) return; |
| 105 | 1185 |
|
508
5a2132ba2220
Add "/buffer up" and "/buffer down"
Mikael Berthe <mikael@lilotux.net>
parents:
503
diff
changeset
|
1186 if (!nblines) { |
|
5a2132ba2220
Add "/buffer up" and "/buffer down"
Mikael Berthe <mikael@lilotux.net>
parents:
503
diff
changeset
|
1187 // Scroll half a screen (or less) |
| 512 | 1188 nbl = CHAT_WIN_HEIGHT/2; |
|
508
5a2132ba2220
Add "/buffer up" and "/buffer down"
Mikael Berthe <mikael@lilotux.net>
parents:
503
diff
changeset
|
1189 } else { |
|
5a2132ba2220
Add "/buffer up" and "/buffer down"
Mikael Berthe <mikael@lilotux.net>
parents:
503
diff
changeset
|
1190 nbl = nblines; |
|
5a2132ba2220
Add "/buffer up" and "/buffer down"
Mikael Berthe <mikael@lilotux.net>
parents:
503
diff
changeset
|
1191 } |
| 105 | 1192 hbuf_top = win_entry->top; |
| 1193 | |
|
361
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1194 if (updown == -1) { // UP |
|
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1195 if (!hbuf_top) { |
|
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1196 hbuf_top = g_list_last(win_entry->hbuf); |
| 512 | 1197 if (!win_entry->cleared) { |
| 1198 if (!nblines) nbl = nbl*3 - 1; | |
| 1199 else nbl += CHAT_WIN_HEIGHT - 1; | |
| 1200 } else { | |
|
361
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1201 win_entry->cleared = FALSE; |
| 512 | 1202 } |
|
361
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1203 } |
|
508
5a2132ba2220
Add "/buffer up" and "/buffer down"
Mikael Berthe <mikael@lilotux.net>
parents:
503
diff
changeset
|
1204 for (n=0 ; hbuf_top && n < nbl && g_list_previous(hbuf_top) ; n++) |
|
361
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1205 hbuf_top = g_list_previous(hbuf_top); |
|
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1206 win_entry->top = hbuf_top; |
|
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1207 } else { // DOWN |
|
508
5a2132ba2220
Add "/buffer up" and "/buffer down"
Mikael Berthe <mikael@lilotux.net>
parents:
503
diff
changeset
|
1208 for (n=0 ; hbuf_top && n < nbl ; n++) |
|
361
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1209 hbuf_top = g_list_next(hbuf_top); |
|
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1210 win_entry->top = hbuf_top; |
|
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1211 // Check if we are at the bottom |
|
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1212 for (n=0 ; hbuf_top && n < CHAT_WIN_HEIGHT-1 ; n++) |
|
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1213 hbuf_top = g_list_next(hbuf_top); |
|
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1214 if (!hbuf_top) |
|
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1215 win_entry->top = NULL; // End reached |
|
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1216 } |
| 105 | 1217 |
| 1218 // Refresh the window | |
| 1219 scr_UpdateWindow(win_entry); | |
| 1220 | |
| 1221 // Finished :) | |
| 1222 update_panels(); | |
| 1223 doupdate(); | |
| 1224 } | |
| 1225 | |
|
369
499170ed71c9
Rename some buffer commands, for homogeneity
Mikael Berthe <mikael@lilotux.net>
parents:
365
diff
changeset
|
1226 // scr_BufferClear() |
| 143 | 1227 // Clear the current buddy window (used for the /clear command) |
|
369
499170ed71c9
Rename some buffer commands, for homogeneity
Mikael Berthe <mikael@lilotux.net>
parents:
365
diff
changeset
|
1228 void scr_BufferClear(void) |
| 108 | 1229 { |
| 1230 window_entry_t *win_entry; | |
| 1231 | |
| 1232 // Get win_entry | |
|
361
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1233 if (!current_buddy) return; |
|
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1234 win_entry = scr_SearchWindow(CURRENT_JID); |
|
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1235 if (!win_entry) return; |
| 108 | 1236 |
| 1237 win_entry->cleared = TRUE; | |
| 109 | 1238 win_entry->top = NULL; |
| 108 | 1239 |
| 1240 // Refresh the window | |
| 1241 scr_UpdateWindow(win_entry); | |
| 1242 | |
| 1243 // Finished :) | |
| 1244 update_panels(); | |
| 1245 doupdate(); | |
| 1246 } | |
| 1247 | |
|
361
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1248 // scr_BufferTopBottom() |
|
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1249 // Jump to the head/tail of the current buddy window |
|
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1250 // (top if topbottom == -1, bottom topbottom == 1) |
|
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1251 void scr_BufferTopBottom(int topbottom) |
| 187 | 1252 { |
| 1253 window_entry_t *win_entry; | |
| 1254 | |
| 1255 // Get win_entry | |
| 1256 if (!current_buddy) return; | |
|
361
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1257 win_entry = scr_SearchWindow(CURRENT_JID); |
| 187 | 1258 if (!win_entry) return; |
| 1259 | |
| 1260 win_entry->cleared = FALSE; | |
|
361
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1261 if (topbottom == 1) |
|
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1262 win_entry->top = NULL; |
|
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1263 else |
|
51ff319947c3
Code cleanup/optimization
Mikael Berthe <mikael@lilotux.net>
parents:
358
diff
changeset
|
1264 win_entry->top = g_list_first(win_entry->hbuf); |
| 187 | 1265 |
| 1266 // Refresh the window | |
| 1267 scr_UpdateWindow(win_entry); | |
| 1268 | |
| 1269 // Finished :) | |
| 1270 update_panels(); | |
| 1271 doupdate(); | |
| 1272 } | |
| 1273 | |
|
370
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1274 // scr_BufferSearch(direction, text) |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1275 // Jump to the next line containing text |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1276 // (backward search if direction == -1, forward if topbottom == 1) |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1277 void scr_BufferSearch(int direction, const char *text) |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1278 { |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1279 window_entry_t *win_entry; |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1280 GList *current_line, *search_res; |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1281 |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1282 // Get win_entry |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1283 if (!current_buddy) return; |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1284 win_entry = scr_SearchWindow(CURRENT_JID); |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1285 if (!win_entry) return; |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1286 |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1287 if (win_entry->top) |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1288 current_line = win_entry->top; |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1289 else |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1290 current_line = g_list_last(win_entry->hbuf); |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1291 |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1292 search_res = hbuf_search(current_line, direction, text); |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1293 |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1294 if (search_res) { |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1295 win_entry->cleared = FALSE; |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1296 win_entry->top = search_res; |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1297 |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1298 // Refresh the window |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1299 scr_UpdateWindow(win_entry); |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1300 |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1301 // Finished :) |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1302 update_panels(); |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1303 doupdate(); |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1304 } else |
|
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
1305 scr_LogPrint(LPRINT_NORMAL, "Search string not found"); |
|
370
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1306 } |
|
dd9e2eb52916
Add /buffer search_{backward,forward}
Mikael Berthe <mikael@lilotux.net>
parents:
369
diff
changeset
|
1307 |
| 462 | 1308 // scr_BufferPercent(n) |
| 1309 // Jump to the specified position in the buffer, in % | |
| 1310 void scr_BufferPercent(int pc) | |
| 1311 { | |
| 1312 window_entry_t *win_entry; | |
| 1313 GList *search_res; | |
| 1314 | |
| 1315 // Get win_entry | |
| 1316 if (!current_buddy) return; | |
| 1317 win_entry = scr_SearchWindow(CURRENT_JID); | |
| 1318 if (!win_entry) return; | |
| 1319 | |
| 1320 if (pc < 0 || pc > 100) { | |
| 1321 scr_LogPrint(LPRINT_NORMAL, "Bad % value"); | |
| 1322 return; | |
| 1323 } | |
| 1324 | |
| 1325 search_res = hbuf_jump_percent(win_entry->hbuf, pc); | |
| 1326 | |
| 1327 win_entry->cleared = FALSE; | |
| 1328 win_entry->top = search_res; | |
| 1329 | |
| 1330 // Refresh the window | |
| 1331 scr_UpdateWindow(win_entry); | |
| 1332 | |
| 1333 // Finished :) | |
| 1334 update_panels(); | |
| 1335 doupdate(); | |
| 1336 } | |
| 1337 | |
| 464 | 1338 // scr_BufferDate(t) |
| 1339 // Jump to the first line after date t in the buffer | |
| 1340 // t is a date in seconds since `00:00:00 1970-01-01 UTC' | |
| 1341 void scr_BufferDate(time_t t) | |
| 1342 { | |
| 1343 window_entry_t *win_entry; | |
| 1344 GList *search_res; | |
| 1345 | |
| 1346 // Get win_entry | |
| 1347 if (!current_buddy) return; | |
| 1348 win_entry = scr_SearchWindow(CURRENT_JID); | |
| 1349 if (!win_entry) return; | |
| 1350 | |
| 1351 search_res = hbuf_jump_date(win_entry->hbuf, t); | |
| 1352 | |
| 1353 win_entry->cleared = FALSE; | |
| 1354 win_entry->top = search_res; | |
| 1355 | |
| 1356 // Refresh the window | |
| 1357 scr_UpdateWindow(win_entry); | |
| 1358 | |
| 1359 // Finished :) | |
| 1360 update_panels(); | |
| 1361 doupdate(); | |
| 1362 } | |
| 1363 | |
| 143 | 1364 // scr_set_chatmode() |
| 261 | 1365 // Public function to (un)set chatmode... |
| 129 | 1366 inline void scr_set_chatmode(int enable) |
| 1367 { | |
| 1368 chatmode = enable; | |
| 1369 } | |
| 1370 | |
| 238 | 1371 // scr_get_multimode() |
| 261 | 1372 // Public function to get multimode status... |
| 238 | 1373 inline int scr_get_multimode() |
| 1374 { | |
| 1375 return multimode; | |
| 1376 } | |
| 1377 | |
|
654
d7fe7b88e4fc
MUC: Set the new_message flag when joining a room
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1378 // scr_setmsgflag_if_needed(jid) |
|
d7fe7b88e4fc
MUC: Set the new_message flag when joining a room
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1379 // Set the message flag unless we're already in the jid buffer window |
|
d7fe7b88e4fc
MUC: Set the new_message flag when joining a room
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1380 void scr_setmsgflag_if_needed(const char *jid) |
|
d7fe7b88e4fc
MUC: Set the new_message flag when joining a room
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1381 { |
|
667
86bc3295a4db
Fix segfault in scr_setmsgflag_if_needed()
Mikael Berthe <mikael@lilotux.net>
parents:
658
diff
changeset
|
1382 const char *current_jid; |
|
86bc3295a4db
Fix segfault in scr_setmsgflag_if_needed()
Mikael Berthe <mikael@lilotux.net>
parents:
658
diff
changeset
|
1383 |
|
86bc3295a4db
Fix segfault in scr_setmsgflag_if_needed()
Mikael Berthe <mikael@lilotux.net>
parents:
658
diff
changeset
|
1384 if (current_buddy) |
|
86bc3295a4db
Fix segfault in scr_setmsgflag_if_needed()
Mikael Berthe <mikael@lilotux.net>
parents:
658
diff
changeset
|
1385 current_jid = buddy_getjid(BUDDATA(current_buddy)); |
|
86bc3295a4db
Fix segfault in scr_setmsgflag_if_needed()
Mikael Berthe <mikael@lilotux.net>
parents:
658
diff
changeset
|
1386 else |
|
86bc3295a4db
Fix segfault in scr_setmsgflag_if_needed()
Mikael Berthe <mikael@lilotux.net>
parents:
658
diff
changeset
|
1387 current_jid = NULL; |
|
86bc3295a4db
Fix segfault in scr_setmsgflag_if_needed()
Mikael Berthe <mikael@lilotux.net>
parents:
658
diff
changeset
|
1388 if (!chatmode || !current_jid || strcmp(jid, current_jid)) |
|
654
d7fe7b88e4fc
MUC: Set the new_message flag when joining a room
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1389 roster_msg_setflag(jid, TRUE); |
|
d7fe7b88e4fc
MUC: Set the new_message flag when joining a room
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1390 } |
|
d7fe7b88e4fc
MUC: Set the new_message flag when joining a room
Mikael Berthe <mikael@lilotux.net>
parents:
652
diff
changeset
|
1391 |
| 238 | 1392 // scr_set_multimode() |
| 261 | 1393 // Public function to (un)set multimode... |
|
260
33e1a05864a6
Add "verbatim multi-line" mode, with commands disabled
mikael@frmp8452
parents:
252
diff
changeset
|
1394 // Convention: |
|
33e1a05864a6
Add "verbatim multi-line" mode, with commands disabled
mikael@frmp8452
parents:
252
diff
changeset
|
1395 // 0 = disabled / 1 = multimode / 2 = multimode verbatim (commands disabled) |
| 238 | 1396 inline void scr_set_multimode(int enable) |
| 1397 { | |
| 1398 if (multiline) { | |
| 1399 g_free(multiline); | |
| 1400 multiline = NULL; | |
| 1401 } | |
|
260
33e1a05864a6
Add "verbatim multi-line" mode, with commands disabled
mikael@frmp8452
parents:
252
diff
changeset
|
1402 multimode = enable; |
| 238 | 1403 } |
| 1404 | |
| 1405 // scr_get_multiline() | |
| 261 | 1406 // Public function to get the current multi-line. |
| 238 | 1407 inline const char *scr_get_multiline() |
| 1408 { | |
| 1409 if (multimode && multiline) | |
| 1410 return multiline; | |
| 1411 else | |
| 1412 return ""; | |
| 1413 } | |
| 1414 | |
| 1415 // scr_append_multiline(line) | |
| 1416 // Public function to append a line to the current multi-line message. | |
| 1417 // Skip empty leading lines. | |
| 1418 void scr_append_multiline(const char *line) | |
| 1419 { | |
| 1420 static int num; | |
| 1421 | |
| 1422 if (!multimode) { | |
|
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
1423 scr_LogPrint(LPRINT_NORMAL, "Error: Not in multi-line message mode!"); |
| 238 | 1424 return; |
| 1425 } | |
| 1426 if (multiline) { | |
| 1427 int len = strlen(multiline)+strlen(line)+2; | |
| 252 | 1428 if (len >= HBB_BLOCKSIZE - 1) { |
| 238 | 1429 // We don't handle single messages with size > HBB_BLOCKSIZE |
| 1430 // (see hbuf) | |
|
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
1431 scr_LogPrint(LPRINT_NORMAL, "Your multi-line message is too big, " |
|
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
1432 "this line has not been added."); |
|
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
1433 scr_LogPrint(LPRINT_NORMAL, "Please send this part now..."); |
| 238 | 1434 return; |
| 1435 } | |
|
276
627925d885de
Limit the number of lines in multi-line messages
Mikael Berthe <mikael@lilotux.net>
parents:
271
diff
changeset
|
1436 if (num >= MULTILINE_MAX_LINE_NUMBER) { |
|
627925d885de
Limit the number of lines in multi-line messages
Mikael Berthe <mikael@lilotux.net>
parents:
271
diff
changeset
|
1437 // We don't allow too many lines; however the maximum is arbitrary |
|
627925d885de
Limit the number of lines in multi-line messages
Mikael Berthe <mikael@lilotux.net>
parents:
271
diff
changeset
|
1438 // (It should be < 1000 yet) |
|
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
1439 scr_LogPrint(LPRINT_NORMAL, "Your message has too many lines, " |
|
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
1440 "this one has not been added."); |
|
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
1441 scr_LogPrint(LPRINT_NORMAL, "Please send this part now..."); |
|
276
627925d885de
Limit the number of lines in multi-line messages
Mikael Berthe <mikael@lilotux.net>
parents:
271
diff
changeset
|
1442 return; |
|
627925d885de
Limit the number of lines in multi-line messages
Mikael Berthe <mikael@lilotux.net>
parents:
271
diff
changeset
|
1443 } |
| 238 | 1444 multiline = g_renew(char, multiline, len); |
| 1445 strcat(multiline, "\n"); | |
| 1446 strcat(multiline, line); | |
| 1447 num++; | |
| 1448 } else { | |
| 1449 // First message line (we skip leading empty lines) | |
| 1450 num = 0; | |
| 1451 if (line[0]) { | |
| 419 | 1452 multiline = g_strdup(line); |
| 238 | 1453 num++; |
| 1454 } else | |
| 1455 return; | |
| 1456 } | |
|
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
1457 scr_LogPrint(LPRINT_NORMAL, "Multi-line mode: line #%d added [%.25s...", |
|
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
1458 num, line); |
| 238 | 1459 } |
| 1460 | |
| 173 | 1461 // scr_cmdhisto_addline() |
| 1462 // Add a line to the inputLine history | |
| 1463 inline void scr_cmdhisto_addline(char *line) | |
| 1464 { | |
| 1465 if (!line || !*line) return; | |
| 1466 | |
| 1467 cmdhisto = g_list_append(cmdhisto, g_strdup(line)); | |
| 1468 } | |
| 1469 | |
| 1470 // scr_cmdhisto_prev() | |
| 1471 // Look for previous line beginning w/ the given mask in the inputLine history | |
| 175 | 1472 // Returns NULL if none found |
|
336
eb994ee40029
Make some functions static
Mikael Berthe <mikael@lilotux.net>
parents:
332
diff
changeset
|
1473 static const char *scr_cmdhisto_prev(char *mask, guint len) |
| 173 | 1474 { |
| 1475 GList *hl; | |
| 1476 if (!cmdhisto_cur) { | |
| 1477 hl = g_list_last(cmdhisto); | |
| 174 | 1478 if (hl) { // backup current line |
| 1479 strncpy(cmdhisto_backup, mask, INPUTLINE_LENGTH); | |
| 1480 } | |
| 173 | 1481 } else { |
| 1482 hl = g_list_previous(cmdhisto_cur); | |
| 1483 } | |
| 1484 while (hl) { | |
| 1485 if (!strncmp((char*)hl->data, mask, len)) { | |
| 1486 // Found a match | |
| 1487 cmdhisto_cur = hl; | |
| 1488 return (const char*)hl->data; | |
| 1489 } | |
| 1490 hl = g_list_previous(hl); | |
| 1491 } | |
| 1492 return NULL; | |
| 1493 } | |
| 1494 | |
| 1495 // scr_cmdhisto_next() | |
| 1496 // Look for next line beginning w/ the given mask in the inputLine history | |
| 175 | 1497 // Returns NULL if none found |
|
336
eb994ee40029
Make some functions static
Mikael Berthe <mikael@lilotux.net>
parents:
332
diff
changeset
|
1498 static const char *scr_cmdhisto_next(char *mask, guint len) |
| 173 | 1499 { |
| 1500 GList *hl; | |
| 1501 if (!cmdhisto_cur) return NULL; | |
| 1502 hl = cmdhisto_cur; | |
| 1503 while ((hl = g_list_next(hl)) != NULL) | |
| 1504 if (!strncmp((char*)hl->data, mask, len)) { | |
| 1505 // Found a match | |
| 1506 cmdhisto_cur = hl; | |
| 1507 return (const char*)hl->data; | |
| 1508 } | |
| 175 | 1509 // If the "backuped" line matches, we'll use it |
| 1510 if (strncmp(cmdhisto_backup, mask, len)) return NULL; // No match | |
| 174 | 1511 cmdhisto_cur = NULL; |
| 1512 return cmdhisto_backup; | |
| 173 | 1513 } |
| 1514 | |
| 195 | 1515 // readline_transpose_chars() |
| 1516 // Drag the character before point forward over the character at | |
| 1517 // point, moving point forward as well. If point is at the end of | |
| 1518 // the line, then this transposes the two characters before point. | |
| 1519 void readline_transpose_chars() | |
| 1520 { | |
| 1521 char swp; | |
| 1522 | |
| 1523 if (ptr_inputline == inputLine) return; | |
| 1524 | |
| 1525 if (!*ptr_inputline) { // We're at EOL | |
| 1526 // If line is only 1 char long, nothing to do... | |
| 1527 if (ptr_inputline == inputLine+1) return; | |
| 1528 // Transpose the two previous characters | |
| 1529 swp = *(ptr_inputline-2); | |
| 1530 *(ptr_inputline-2) = *(ptr_inputline-1); | |
| 1531 *(ptr_inputline-1) = swp; | |
| 1532 } else { | |
| 196 | 1533 // Swap the two characters before the cursor and move right. |
| 195 | 1534 swp = *(ptr_inputline-1); |
| 1535 *(ptr_inputline-1) = *ptr_inputline; | |
| 1536 *ptr_inputline++ = swp; | |
| 1537 check_offset(1); | |
| 1538 } | |
| 1539 } | |
| 1540 | |
| 1541 // readline_backward_kill_word() | |
| 194 | 1542 // Kill the word before the cursor, in input line |
| 195 | 1543 void readline_backward_kill_word() |
| 194 | 1544 { |
| 1545 char *c, *old = ptr_inputline; | |
| 1546 int spaceallowed = 1; | |
| 1547 | |
| 1548 if (ptr_inputline == inputLine) return; | |
| 1549 | |
| 1550 for (c = ptr_inputline-1 ; c > inputLine ; c--) | |
| 1551 if (!isalnum(*c)) { | |
| 1552 if (*c == ' ') | |
| 1553 if (!spaceallowed) break; | |
| 1554 } else spaceallowed = 0; | |
| 1555 | |
| 1556 if (c != inputLine || *c != ' ') | |
| 1557 if ((c < ptr_inputline-1) && (!isalnum(*c))) | |
| 1558 c++; | |
| 1559 | |
| 1560 // Modify the line | |
| 1561 ptr_inputline = c; | |
| 1562 for (;;) { | |
| 1563 *c = *old++; | |
| 1564 if (!*c++) break; | |
| 1565 } | |
| 195 | 1566 check_offset(-1); |
| 194 | 1567 } |
| 1568 | |
| 98 | 1569 // which_row() |
| 1570 // Tells which row our cursor is in, in the command line. | |
|
503
ddec224c2318
MUC: nickname completion
Mikael Berthe <mikael@lilotux.net>
parents:
499
diff
changeset
|
1571 // -2 -> normal text |
|
ddec224c2318
MUC: nickname completion
Mikael Berthe <mikael@lilotux.net>
parents:
499
diff
changeset
|
1572 // -1 -> room: nickname completion |
| 98 | 1573 // 0 -> command |
| 1574 // 1 -> parameter 1 (etc.) | |
| 102 | 1575 // If > 0, then *p_row is set to the beginning of the row |
|
503
ddec224c2318
MUC: nickname completion
Mikael Berthe <mikael@lilotux.net>
parents:
499
diff
changeset
|
1576 static int which_row(const char **p_row) |
| 98 | 1577 { |
| 1578 int row = -1; | |
| 1579 char *p; | |
| 1580 int quote = FALSE; | |
| 1581 | |
| 1582 // Not a command? | |
|
503
ddec224c2318
MUC: nickname completion
Mikael Berthe <mikael@lilotux.net>
parents:
499
diff
changeset
|
1583 if ((ptr_inputline == inputLine) || (inputLine[0] != '/')) { |
|
ddec224c2318
MUC: nickname completion
Mikael Berthe <mikael@lilotux.net>
parents:
499
diff
changeset
|
1584 if (!current_buddy) return -2; |
|
ddec224c2318
MUC: nickname completion
Mikael Berthe <mikael@lilotux.net>
parents:
499
diff
changeset
|
1585 if (buddy_gettype(BUDDATA(current_buddy)) == ROSTER_TYPE_ROOM) { |
|
ddec224c2318
MUC: nickname completion
Mikael Berthe <mikael@lilotux.net>
parents:
499
diff
changeset
|
1586 *p_row = inputLine; |
|
ddec224c2318
MUC: nickname completion
Mikael Berthe <mikael@lilotux.net>
parents:
499
diff
changeset
|
1587 return -1; |
|
ddec224c2318
MUC: nickname completion
Mikael Berthe <mikael@lilotux.net>
parents:
499
diff
changeset
|
1588 } |
|
ddec224c2318
MUC: nickname completion
Mikael Berthe <mikael@lilotux.net>
parents:
499
diff
changeset
|
1589 return -2; |
|
ddec224c2318
MUC: nickname completion
Mikael Berthe <mikael@lilotux.net>
parents:
499
diff
changeset
|
1590 } |
| 98 | 1591 |
| 1592 // This is a command | |
| 1593 row = 0; | |
| 1594 for (p = inputLine ; p < ptr_inputline ; p++) { | |
| 1595 if (quote) { | |
| 1596 if (*p == '"' && *(p-1) != '\\') | |
| 1597 quote = FALSE; | |
| 1598 continue; | |
| 1599 } | |
| 1600 if (*p == '"' && *(p-1) != '\\') { | |
| 1601 quote = TRUE; | |
| 121 | 1602 } else if (*p == ' ') { |
| 1603 if (*(p-1) != ' ') | |
| 1604 row++; | |
| 102 | 1605 *p_row = p+1; |
| 1606 } | |
| 98 | 1607 } |
| 1608 return row; | |
| 1609 } | |
| 1610 | |
| 143 | 1611 // scr_insert_text() |
| 1612 // Insert the given text at the current cursor position. | |
| 1613 // The cursor is moved. We don't check if the cursor still is in the screen | |
| 1614 // after, the caller should do that. | |
|
336
eb994ee40029
Make some functions static
Mikael Berthe <mikael@lilotux.net>
parents:
332
diff
changeset
|
1615 static void scr_insert_text(const char *text) |
| 98 | 1616 { |
| 1617 char tmpLine[INPUTLINE_LENGTH+1]; | |
| 1618 int len = strlen(text); | |
| 1619 // Check the line isn't too long | |
| 1620 if (strlen(inputLine) + len >= INPUTLINE_LENGTH) { | |
|
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
1621 scr_LogPrint(LPRINT_LOGNORM, "Cannot insert text, line too long."); |
| 98 | 1622 return; |
| 1623 } | |
| 1624 | |
| 1625 strcpy(tmpLine, ptr_inputline); | |
| 419 | 1626 strcpy(ptr_inputline, text); |
| 1627 ptr_inputline += len; | |
| 98 | 1628 strcpy(ptr_inputline, tmpLine); |
| 1629 } | |
| 1630 | |
| 143 | 1631 // scr_handle_tab() |
| 1632 // Function called when tab is pressed. | |
| 1633 // Initiate or continue a completion... | |
|
336
eb994ee40029
Make some functions static
Mikael Berthe <mikael@lilotux.net>
parents:
332
diff
changeset
|
1634 static void scr_handle_tab(void) |
| 98 | 1635 { |
| 102 | 1636 int nrow; |
|
503
ddec224c2318
MUC: nickname completion
Mikael Berthe <mikael@lilotux.net>
parents:
499
diff
changeset
|
1637 const char *row; |
| 102 | 1638 const char *cchar; |
| 103 | 1639 guint compl_categ; |
| 98 | 1640 |
| 102 | 1641 nrow = which_row(&row); |
| 98 | 1642 |
|
503
ddec224c2318
MUC: nickname completion
Mikael Berthe <mikael@lilotux.net>
parents:
499
diff
changeset
|
1643 // a) No completion if no leading slash ('cause not a command), |
|
ddec224c2318
MUC: nickname completion
Mikael Berthe <mikael@lilotux.net>
parents:
499
diff
changeset
|
1644 // unless this is a room (then, it is a nickname completion) |
| 103 | 1645 // b) We can't have more than 2 parameters (we use 2 flags) |
|
503
ddec224c2318
MUC: nickname completion
Mikael Berthe <mikael@lilotux.net>
parents:
499
diff
changeset
|
1646 if ((nrow == -2) || (nrow == 3 && !completion_started) || nrow > 3) |
|
ddec224c2318
MUC: nickname completion
Mikael Berthe <mikael@lilotux.net>
parents:
499
diff
changeset
|
1647 return; |
| 102 | 1648 |
|
503
ddec224c2318
MUC: nickname completion
Mikael Berthe <mikael@lilotux.net>
parents:
499
diff
changeset
|
1649 if (nrow == 0) { // Command completion |
| 103 | 1650 row = &inputLine[1]; |
| 1651 compl_categ = COMPL_CMD; | |
|
503
ddec224c2318
MUC: nickname completion
Mikael Berthe <mikael@lilotux.net>
parents:
499
diff
changeset
|
1652 } else if (nrow == -1) { // Nickname completion |
|
ddec224c2318
MUC: nickname completion
Mikael Berthe <mikael@lilotux.net>
parents:
499
diff
changeset
|
1653 compl_categ = COMPL_RESOURCE; |
|
ddec224c2318
MUC: nickname completion
Mikael Berthe <mikael@lilotux.net>
parents:
499
diff
changeset
|
1654 } else { // Other completion, depending on the command |
| 285 | 1655 int alias = FALSE; |
| 1656 cmd *com; | |
| 1657 char *xpline = expandalias(inputLine); | |
| 1658 com = cmd_get(xpline); | |
| 1659 if (xpline != inputLine) { | |
| 1660 // This is an alias, so we can't complete rows > 0 | |
| 1661 alias = TRUE; | |
| 1662 g_free(xpline); | |
| 1663 } | |
| 1664 if ((!com && (!alias || !completion_started)) || !row) { | |
|
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
373
diff
changeset
|
1665 scr_LogPrint(LPRINT_NORMAL, "I cannot complete that..."); |
| 103 | 1666 return; |
| 1667 } | |
| 285 | 1668 if (!alias) |
| 1669 compl_categ = com->completion_flags[nrow-1]; | |
| 1670 else | |
| 1671 compl_categ = 0; | |
| 103 | 1672 } |
| 1673 | |
| 1674 if (!completion_started) { | |
| 1675 GSList *list = compl_get_category_list(compl_categ); | |
| 1676 if (list) { | |
| 1677 char *prefix = g_strndup(row, ptr_inputline-row); | |
| 1678 // Init completion | |
| 1679 new_completion(prefix, list); | |
| 1680 g_free(prefix); | |
| 1681 // Now complete | |
| 98 | 1682 cchar = complete(); |
| 1683 if (cchar) | |
| 1684 scr_insert_text(cchar); | |
| 103 | 1685 completion_started = TRUE; |
| 98 | 1686 } |
| 103 | 1687 } else { // Completion already initialized |
| 1688 char *c; | |
| 1689 guint back = cancel_completion(); | |
| 1690 // Remove $back chars | |
| 1691 ptr_inputline -= back; | |
| 1692 c = ptr_inputline; | |
| 1693 for ( ; *c ; c++) | |
| 1694 *c = *(c+back); | |
| 1695 // Now complete again | |
| 1696 cchar = complete(); | |
| 1697 if (cchar) | |
| 1698 scr_insert_text(cchar); | |
| 102 | 1699 } |
| 98 | 1700 } |
| 1701 | |
|
336
eb994ee40029
Make some functions static
Mikael Berthe <mikael@lilotux.net>
parents:
332
diff
changeset
|
1702 static void scr_cancel_current_completion(void) |
| 98 | 1703 { |
| 1704 char *c; | |
| 1705 guint back = cancel_completion(); | |
| 1706 // Remove $back chars | |
| 1707 ptr_inputline -= back; | |
| 1708 c = ptr_inputline; | |
| 1709 for ( ; *c ; c++) | |
| 1710 *c = *(c+back); | |
| 1711 } | |
| 1712 | |
|
336
eb994ee40029
Make some functions static
Mikael Berthe <mikael@lilotux.net>
parents:
332
diff
changeset
|
1713 static void scr_end_current_completion(void) |
| 98 | 1714 { |
| 1715 done_completion(); | |
| 1716 completion_started = FALSE; | |
| 1717 } | |
| 1718 | |
| 24 | 1719 // check_offset(int direction) |
| 1720 // Check inputline_offset value, and make sure the cursor is inside the | |
| 1721 // screen. | |
|
336
eb994ee40029
Make some functions static
Mikael Berthe <mikael@lilotux.net>
parents:
332
diff
changeset
|
1722 static inline void check_offset(int direction) |
| 24 | 1723 { |
| 1724 // Left side | |
| 1725 if (inputline_offset && direction <= 0) { | |
| 1726 while (ptr_inputline <= (char*)&inputLine + inputline_offset) { | |
| 1727 if (inputline_offset) { | |
| 1728 inputline_offset -= 5; | |
| 1729 if (inputline_offset < 0) | |
| 1730 inputline_offset = 0; | |
| 1731 } | |
| 1732 } | |
| 1733 } | |
| 1734 // Right side | |
| 1735 if (direction >= 0) { | |
| 1736 while (ptr_inputline >= inputline_offset + (char*)&inputLine + maxX) | |
| 1737 inputline_offset += 5; | |
| 1738 } | |
| 1739 } | |
| 1740 | |
|
336
eb994ee40029
Make some functions static
Mikael Berthe <mikael@lilotux.net>
parents:
332
diff
changeset
|
1741 static inline void refresh_inputline(void) |
|
312
f0b7ff2df7e8
Ctrl-C does not terminate mcabber
Mikael Berthe <mikael@lilotux.net>
parents:
307
diff
changeset
|
1742 { |
|
f0b7ff2df7e8
Ctrl-C does not terminate mcabber
Mikael Berthe <mikael@lilotux.net>
parents:
307
diff
changeset
|
1743 mvwprintw(inputWnd, 0,0, "%s", inputLine + inputline_offset); |
|
f0b7ff2df7e8
Ctrl-C does not terminate mcabber
Mikael Berthe <mikael@lilotux.net>
parents:
307
diff
changeset
|
1744 wclrtoeol(inputWnd); |
|
f0b7ff2df7e8
Ctrl-C does not terminate mcabber
Mikael Berthe <mikael@lilotux.net>
parents:
307
diff
changeset
|
1745 if (*ptr_inputline) |
|
f0b7ff2df7e8
Ctrl-C does not terminate mcabber
Mikael Berthe <mikael@lilotux.net>
parents:
307
diff
changeset
|
1746 wmove(inputWnd, 0, ptr_inputline - (char*)&inputLine - inputline_offset); |
|
f0b7ff2df7e8
Ctrl-C does not terminate mcabber
Mikael Berthe <mikael@lilotux.net>
parents:
307
diff
changeset
|
1747 } |
|
f0b7ff2df7e8
Ctrl-C does not terminate mcabber
Mikael Berthe <mikael@lilotux.net>
parents:
307
diff
changeset
|
1748 |
|
389
6e895f397474
Ncurses changes + Ctrl-C does not send a signal anylore
Mikael Berthe <mikael@lilotux.net>
parents:
388
diff
changeset
|
1749 void scr_handle_CtrlC(void) |
|
312
f0b7ff2df7e8
Ctrl-C does not terminate mcabber
Mikael Berthe <mikael@lilotux.net>
parents:
307
diff
changeset
|
1750 { |
|
365
ddb6593bedc9
Fix segfault when mcabber receives an INT signal (Ctrl-C) early
Mikael Berthe <mikael@lilotux.net>
parents:
364
diff
changeset
|
1751 if (!Curses) return; |
|
315
65aa05520556
First Ctrl-C now also leaves multi-line message mode
Mikael Berthe <mikael@lilotux.net>
parents:
314
diff
changeset
|
1752 // Leave multi-line mode |
|
65aa05520556
First Ctrl-C now also leaves multi-line message mode
Mikael Berthe <mikael@lilotux.net>
parents:
314
diff
changeset
|
1753 process_command("/msay abort"); |
|
312
f0b7ff2df7e8
Ctrl-C does not terminate mcabber
Mikael Berthe <mikael@lilotux.net>
parents:
307
diff
changeset
|
1754 // Same as Ctrl-g, now |
|
f0b7ff2df7e8
Ctrl-C does not terminate mcabber
Mikael Berthe <mikael@lilotux.net>
parents:
307
diff
changeset
|
1755 scr_cancel_current_completion(); |
|
f0b7ff2df7e8
Ctrl-C does not terminate mcabber
Mikael Berthe <mikael@lilotux.net>
parents:
307
diff
changeset
|
1756 scr_end_current_completion(); |
|
f0b7ff2df7e8
Ctrl-C does not terminate mcabber
Mikael Berthe <mikael@lilotux.net>
parents:
307
diff
changeset
|
1757 check_offset(-1); |
|
f0b7ff2df7e8
Ctrl-C does not terminate mcabber
Mikael Berthe <mikael@lilotux.net>
parents:
307
diff
changeset
|
1758 refresh_inputline(); |
|
f0b7ff2df7e8
Ctrl-C does not terminate mcabber
Mikael Berthe <mikael@lilotux.net>
parents:
307
diff
changeset
|
1759 } |
|
f0b7ff2df7e8
Ctrl-C does not terminate mcabber
Mikael Berthe <mikael@lilotux.net>
parents:
307
diff
changeset
|
1760 |
|
373
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1761 int scr_Getch(void) |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1762 { |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1763 int ch; |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1764 ch = wgetch(inputWnd); |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1765 return ch; |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1766 } |
|
af2f8ddf6a1b
Move (reorganize) functions
Mikael Berthe <mikael@lilotux.net>
parents:
370
diff
changeset
|
1767 |
| 44 | 1768 // process_key(key) |
| 1769 // Handle the pressed key, in the command line (bottom). | |
| 29 | 1770 int process_key(int key) |
| 24 | 1771 { |
|
499
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1772 switch(key) { |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1773 case 8: // Ctrl-h |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1774 case 127: // Backspace too |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1775 case KEY_BACKSPACE: |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1776 if (ptr_inputline != (char*)&inputLine) { |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1777 char *c = --ptr_inputline; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1778 for ( ; *c ; c++) |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1779 *c = *(c+1); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1780 check_offset(-1); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1781 } |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1782 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1783 case KEY_DC:// Del |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1784 if (*ptr_inputline) |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1785 strcpy(ptr_inputline, ptr_inputline+1); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1786 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1787 case KEY_LEFT: |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1788 if (ptr_inputline != (char*)&inputLine) { |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1789 ptr_inputline--; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1790 check_offset(-1); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1791 } |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1792 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1793 case KEY_RIGHT: |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1794 if (*ptr_inputline) |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1795 ptr_inputline++; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1796 check_offset(1); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1797 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1798 case 7: // Ctrl-g |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1799 scr_cancel_current_completion(); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1800 scr_end_current_completion(); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1801 check_offset(-1); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1802 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1803 case 9: // Tab |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1804 scr_handle_tab(); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1805 check_offset(0); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1806 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1807 case 13: // Enter |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1808 case 15: // Ctrl-o ("accept-line-and-down-history") |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1809 scr_CheckAutoAway(TRUE); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1810 if (process_line(inputLine)) |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1811 return 255; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1812 // Add line to history |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1813 scr_cmdhisto_addline(inputLine); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1814 // Reset the line |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1815 ptr_inputline = inputLine; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1816 *ptr_inputline = 0; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1817 inputline_offset = 0; |
| 24 | 1818 |
|
499
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1819 if (key == 13) // Enter |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1820 { |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1821 // Reset history line pointer |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1822 cmdhisto_cur = NULL; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1823 } else { // down-history |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1824 // Use next history line instead of a blank line |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1825 const char *l = scr_cmdhisto_next("", 0); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1826 if (l) strcpy(inputLine, l); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1827 // Reset backup history line |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1828 cmdhisto_backup[0] = 0; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1829 } |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1830 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1831 case KEY_UP: |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1832 { |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1833 const char *l = scr_cmdhisto_prev(inputLine, |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1834 ptr_inputline-inputLine); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1835 if (l) strcpy(inputLine, l); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1836 } |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1837 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1838 case KEY_DOWN: |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1839 { |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1840 const char *l = scr_cmdhisto_next(inputLine, |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1841 ptr_inputline-inputLine); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1842 if (l) strcpy(inputLine, l); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1843 } |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1844 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1845 case KEY_PPAGE: |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1846 scr_CheckAutoAway(TRUE); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1847 scr_RosterUp(); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1848 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1849 case KEY_NPAGE: |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1850 scr_CheckAutoAway(TRUE); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1851 scr_RosterDown(); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1852 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1853 case KEY_HOME: |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1854 case 1: |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1855 ptr_inputline = inputLine; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1856 inputline_offset = 0; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1857 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1858 case 3: // Ctrl-C |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1859 scr_handle_CtrlC(); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1860 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1861 case KEY_END: |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1862 case 5: |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1863 for (; *ptr_inputline; ptr_inputline++) ; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1864 check_offset(1); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1865 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1866 case 21: // Ctrl-u |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1867 strcpy(inputLine, ptr_inputline); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1868 ptr_inputline = inputLine; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1869 inputline_offset = 0; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1870 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1871 case KEY_EOL: |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1872 case 11: // Ctrl-k |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1873 *ptr_inputline = 0; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1874 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1875 case 16: // Ctrl-p |
|
508
5a2132ba2220
Add "/buffer up" and "/buffer down"
Mikael Berthe <mikael@lilotux.net>
parents:
503
diff
changeset
|
1876 scr_BufferScrollUpDown(-1, 0); |
|
499
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1877 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1878 case 14: // Ctrl-n |
|
508
5a2132ba2220
Add "/buffer up" and "/buffer down"
Mikael Berthe <mikael@lilotux.net>
parents:
503
diff
changeset
|
1879 scr_BufferScrollUpDown(1, 0); |
|
499
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1880 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1881 case 17: // Ctrl-q |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1882 scr_CheckAutoAway(TRUE); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1883 scr_RosterUnreadMessage(1); // next unread message |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1884 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1885 case 20: // Ctrl-t |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1886 readline_transpose_chars(); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1887 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1888 case 23: // Ctrl-w |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1889 readline_backward_kill_word(); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1890 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1891 case 27: // ESC |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1892 scr_CheckAutoAway(TRUE); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1893 currentWindow = NULL; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1894 chatmode = FALSE; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1895 if (current_buddy) |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1896 buddy_setflags(BUDDATA(current_buddy), ROSTER_FLAG_LOCK, FALSE); |
|
709
5aa66101807b
Leave full-width mode automatically under some conditions
Mikael Berthe <mikael@lilotux.net>
parents:
708
diff
changeset
|
1897 scr_RosterVisibility(1); |
|
499
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1898 top_panel(chatPanel); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1899 top_panel(inputPanel); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1900 update_panels(); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1901 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1902 case 12: // Ctrl-l |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1903 scr_CheckAutoAway(TRUE); |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
1904 scr_Resize(); |
|
499
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1905 redrawwin(stdscr); |
|
701
6c100adfbfb6
Add setting "roster_width" (variable buddylist width)
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
1906 break; |
|
499
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1907 case KEY_RESIZE: |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1908 scr_Resize(); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1909 break; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1910 default: |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1911 if (isprint(key)) { |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1912 char tmpLine[INPUTLINE_LENGTH+1]; |
| 263 | 1913 |
|
499
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1914 // Check the line isn't too long |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1915 if (strlen(inputLine) >= INPUTLINE_LENGTH) |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1916 return 0; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1917 |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1918 // Insert char |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1919 strcpy(tmpLine, ptr_inputline); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1920 *ptr_inputline++ = key; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1921 strcpy(ptr_inputline, tmpLine); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1922 check_offset(1); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1923 } else { |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1924 const gchar *boundcmd = isbound(key); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1925 if (boundcmd) { |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1926 gchar *cmd = g_strdup_printf("/%s", boundcmd); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1927 scr_CheckAutoAway(TRUE); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1928 if (process_command(cmd)) |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1929 return 255; |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1930 g_free(cmd); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1931 } else { |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1932 scr_LogPrint(LPRINT_NORMAL, "Unknown key=%d", key); |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1933 if (utf8_mode) |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1934 scr_LogPrint(LPRINT_NORMAL, |
|
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1935 "WARNING: UTF-8 not yet supported!"); |
| 175 | 1936 } |
|
499
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1937 } |
| 24 | 1938 } |
|
499
baa812f04f24
Reorganise process_key()
Mikael Berthe <mikael@lilotux.net>
parents:
480
diff
changeset
|
1939 |
| 157 | 1940 if (completion_started && key != 9 && key != KEY_RESIZE) |
| 98 | 1941 scr_end_current_completion(); |
|
312
f0b7ff2df7e8
Ctrl-C does not terminate mcabber
Mikael Berthe <mikael@lilotux.net>
parents:
307
diff
changeset
|
1942 refresh_inputline(); |
|
f0b7ff2df7e8
Ctrl-C does not terminate mcabber
Mikael Berthe <mikael@lilotux.net>
parents:
307
diff
changeset
|
1943 if (!update_roster) |
| 157 | 1944 doupdate(); |
| 24 | 1945 return 0; |
| 1946 } | |
| 576 | 1947 |
| 580 | 1948 /* vim: set expandtab cindent cinoptions=>2\:2(0: For Vim users... */ |