?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Create FUNDING.yml
[wdl/wdl-ol.git] / WDL / win32_curses / curses_editor.cpp
blob2bfc8147edc420ee64135a8747329fbd9138d87f
1 #ifdef _WIN32
2 #include <windows.h>
3 #else
4 #include "../swell/swell.h"
5 #endif
6 #include <stdlib.h>
7 #include <string.h>
8 #ifndef CURSES_INSTANCE
9 #define CURSES_INSTANCE ((win32CursesCtx*)m_cursesCtx)
10 #endif
11
12 #include "curses_editor.h"
13 #include "../wdlutf8.h"
14 #include "../win32_utf8.h"
15 #include "../wdlcstring.h"
16
17 #ifndef VALIDATE_TEXT_CHAR
18 #define VALIDATE_TEXT_CHAR(thischar) ((thischar) >= 0 && (thischar >= 128 || isspace(thischar) || isgraph(thischar)) && !(thischar >= KEY_DOWN && thischar <= KEY_F12))
19 #endif
20
21
22
23 #ifdef __APPLE__
24 #define CONTROL_KEY_NAME "Cmd"
25 #else
26 #define CONTROL_KEY_NAME "Ctrl"
27 #endif
28
29 WDL_FastString WDL_CursesEditor::s_fake_clipboard;
30 int WDL_CursesEditor::s_overwrite=0;
31 char WDL_CursesEditor::s_search_string[256];
32
33 #ifndef WM_MOUSEWHEEL
34 #define WM_MOUSEWHEEL 0x20A
35 #endif
36
37 static void __curses_onresize(win32CursesCtx *ctx)
38 {
39 WDL_CursesEditor *p = (WDL_CursesEditor *)ctx->user_data;
40 if (p)
41 {
42 p->draw();
43 p->setCursor();
44 }
45 }
46 WDL_CursesEditor::WDL_CursesEditor(void *cursesCtx)
47 {
48 m_newline_mode=0;
49 m_write_leading_tabs=0;
50 m_max_undo_states = 500;
51 m_indent_size=2;
52 m_cursesCtx = cursesCtx;
53
54 m_top_margin=1;
55 m_bottom_margin=1;
56
57 m_selecting=0;
58 m_select_x1=m_select_y1=m_select_x2=m_select_y2=0;
59 m_ui_state=UI_STATE_NORMAL;
60 m_offs_x=0;
61 m_curs_x=m_curs_y=0;
62 m_want_x=-1;
63 m_undoStack_pos=-1;
64 m_clean_undopos=0;
65
66 m_curpane=0;
67 m_pane_div=1.0;
68 m_paneoffs_y[0]=m_paneoffs_y[1]=0;
69
70 m_curpane=0;
71 m_scrollcap=0;
72 m_scrollcap_yoffs=0;
73
74 m_filelastmod=0;
75 m_status_lastlen=0;
76
77 #ifdef WDL_IS_FAKE_CURSES
78 if (m_cursesCtx)
79 {
80 CURSES_INSTANCE->user_data = this;
81 CURSES_INSTANCE->onMouseMessage = _onMouseMessage;
82 CURSES_INSTANCE->want_scrollbar=1; // 1 or 2 chars wide
83 CURSES_INSTANCE->do_update = __curses_onresize;
84 }
85 #endif
86
87 initscr();
88 cbreak();
89 noecho();
90 nonl();
91 intrflush(stdscr,FALSE);
92 keypad(stdscr,TRUE);
93 nodelay(stdscr,TRUE);
94 raw(); // disable ctrl+C etc. no way to kill if allow quit isn't defined, yay.
95 start_color();
96
97 #ifdef WDL_IS_FAKE_CURSES
98 if (!curses_win32_global_user_colortab && (!m_cursesCtx || !CURSES_INSTANCE->user_colortab))
99 #endif
100 {
101 init_pair(1, COLOR_WHITE, COLOR_BLUE); // COLOR_BOTTOMLINE
102 init_pair(2, COLOR_BLACK, COLOR_CYAN); // COLOR_SELECTION
103 init_pair(3, RGB(0,255,255),COLOR_BLACK); // SYNTAX_HIGHLIGHT1
104 init_pair(4, RGB(0,255,0),COLOR_BLACK); // SYNTAX_HIGHLIGHT2
105 init_pair(5, RGB(96,128,192),COLOR_BLACK); // SYNTAX_COMMENT
106 init_pair(6, COLOR_WHITE, COLOR_RED); // SYNTAX_ERROR
107 init_pair(7, RGB(255,255,0), COLOR_BLACK); // SYNTAX_FUNC
108
109 #ifdef WDL_IS_FAKE_CURSES
110 init_pair(8, RGB(255,128,128), COLOR_BLACK); // SYNTAX_REGVAR
111 init_pair(9, RGB(0,192,255), COLOR_BLACK); // SYNTAX_KEYWORD
112 init_pair(10, RGB(255,192,192), COLOR_BLACK); // SYNTAX_STRING
113 init_pair(11, RGB(192,255,128), COLOR_BLACK); // SYNTAX_STRINGVAR
114 init_pair(12, COLOR_BLACK, COLOR_CYAN); // COLOR_MESSAGE (maps to COLOR_SELECTION)
115 init_pair(13, COLOR_WHITE, COLOR_RED); // COLOR_TOPLINE (maps to SYNTAX_ERROR)
116 init_pair(14, RGB(192,192,0), COLOR_BLACK); // SYNTAX_FUNC2
117 #endif
118 }
119
120 erase();
121 refresh();
122 }
123
124 int WDL_CursesEditor::GetPaneDims(int* paney, int* paneh) // returns ypos of divider
125 {
126 const int pane_divy=(int)(m_pane_div*(double)(LINES-m_top_margin-m_bottom_margin-1));
127 if (paney)
128 {
129 paney[0]=m_top_margin;
130 paney[1]=m_top_margin+pane_divy+1;
131 }
132 if (paneh)
133 {
134 paneh[0]=pane_divy+(m_pane_div >= 1.0 ? 1 : 0);
135 paneh[1]=LINES-pane_divy-m_top_margin-m_bottom_margin-1;
136
137 }
138 return pane_divy;
139 }
140
141
142 int WDL_CursesEditor::getVisibleLines() const { return LINES-m_bottom_margin-m_top_margin; }
143
144
145 #ifdef WDL_IS_FAKE_CURSES
146 LRESULT WDL_CursesEditor::onMouseMessage(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
147 {
148 static int s_mousedown[2];
149
150 switch (uMsg)
151 {
152 case WM_CAPTURECHANGED:
153 break;
154
155 case WM_MOUSEMOVE:
156 if (GetCapture()==hwnd && CURSES_INSTANCE->m_font_w && CURSES_INSTANCE->m_font_h)
157 {
158 POINT pt = { (short)LOWORD(lParam), (short)HIWORD(lParam) };
159 int cx=pt.x/CURSES_INSTANCE->m_font_w;
160 int cy=pt.y/CURSES_INSTANCE->m_font_h;
161
162 int paney[2], paneh[2];
163 const int pane_divy=GetPaneDims(paney, paneh);
164
165 if (m_scrollcap)
166 {
167 int i=m_scrollcap-1;
168
169 if (i == 2) // divider
170 {
171 int divy=cy-paney[0];
172 if (divy != pane_divy)
173 {
174 if (divy <= 0 || divy >= LINES-m_top_margin-m_bottom_margin-1)
175 {
176 if (divy <= 0.0) m_paneoffs_y[0]=m_paneoffs_y[1];
177 m_curpane=0;
178 m_pane_div=1.0;
179 }
180 else
181 {
182 m_pane_div=(double)divy/(double)(LINES-m_top_margin-m_bottom_margin-1);
183 }
184 draw();
185 draw_status_state();
186 }
187 }
188 else
189 {
190 int prevoffs=m_paneoffs_y[i];
191 int pxy=paney[i]*CURSES_INSTANCE->m_font_h;
192 int pxh=paneh[i]*CURSES_INSTANCE->m_font_h;
193
194 if (pxh > CURSES_INSTANCE->scroll_h[i])
195 {
196 m_paneoffs_y[i]=(m_text.GetSize()-paneh[i])*(pt.y-m_scrollcap_yoffs-pxy)/(pxh-CURSES_INSTANCE->scroll_h[i]);
197 int maxscroll=m_text.GetSize()-paneh[i]+4;
198 if (m_paneoffs_y[i] > maxscroll) m_paneoffs_y[i]=maxscroll;
199 if (m_paneoffs_y[i] < 0) m_paneoffs_y[i]=0;
200 }
201
202 if (m_paneoffs_y[i] != prevoffs)
203 {
204 draw();
205 draw_status_state();
206
207 const int col=m_curs_x-m_offs_x;
208 int line=m_curs_y+paney[m_curpane]-m_paneoffs_y[m_curpane];
209 if (line >= paney[m_curpane] && line < paney[m_curpane]+paneh[m_curpane]) move(line, col);
210 }
211 }
212
213 return 0;
214 }
215
216 if (!m_selecting && (cx != s_mousedown[0] || cy != s_mousedown[1]))
217 {
218 m_select_x2=m_select_x1=m_curs_x;
219 m_select_y2=m_select_y1=m_curs_y;
220 m_selecting=1;
221 }
222
223 int x=cx+m_offs_x;
224 int y=cy+m_paneoffs_y[m_curpane]-paney[m_curpane];
225 if (m_selecting && (m_select_x2!=x || m_select_y2 != y))
226 {
227 if (y < m_paneoffs_y[m_curpane] && m_paneoffs_y[m_curpane] > 0)
228 {
229 m_paneoffs_y[m_curpane]--;
230 }
231 else if (y >= m_paneoffs_y[m_curpane]+paneh[m_curpane] && m_paneoffs_y[m_curpane]+paneh[m_curpane] < m_text.GetSize())
232 {
233 m_paneoffs_y[m_curpane]++;
234 }
235 if (x < m_offs_x && m_offs_x > 0)
236 {
237 m_offs_x--;
238 }
239 else if (x > m_offs_x+COLS)
240 {
241 int maxlen=0;
242 int a;
243 for (a=0; a < paneh[m_curpane]; a++)
244 {
245 WDL_FastString* s=m_text.Get(m_paneoffs_y[m_curpane]+a);
246 if (s)
247 {
248 const int l = WDL_utf8_get_charlen(s->Get());
249 if (l > maxlen) maxlen=l;
250 }
251 }
252 if (maxlen > m_offs_x+COLS-8) m_offs_x++;
253 }
254
255 m_select_y2=y;
256 m_select_x2=x;
257 if (m_select_y2<0) m_select_y2=0;
258 else if (m_select_y2>=m_text.GetSize())
259 {
260 m_select_y2=m_text.GetSize()-1;
261 WDL_FastString *s=m_text.Get(m_select_y2);
262 if (s) m_select_x2 = WDL_utf8_get_charlen(s->Get());
263 }
264 if (m_select_x2<0)m_select_x2=0;
265 WDL_FastString *s=m_text.Get(m_select_y2);
266 if (s)
267 {
268 const int l = WDL_utf8_get_charlen(s->Get());
269 if (m_select_x2>l) m_select_x2 = l;
270 }
271 draw();
272
273 int y=m_curs_y+paney[m_curpane]-m_paneoffs_y[m_curpane];
274 if (y >= paney[m_curpane] && y < paney[m_curpane]+paneh[m_curpane]) setCursor();
275 }
276 }
277 break;
278 case WM_LBUTTONDBLCLK:
279 if (CURSES_INSTANCE && CURSES_INSTANCE->m_font_w && CURSES_INSTANCE->m_font_h)
280 {
281 const int y = ((short)HIWORD(lParam)) / CURSES_INSTANCE->m_font_h - m_top_margin;
282 const int x = ((short)LOWORD(lParam)) / CURSES_INSTANCE->m_font_w + m_offs_x;
283 WDL_FastString *fs=m_text.Get(y + m_paneoffs_y[m_curpane]);
284 if (fs && y >= 0)
285 {
286 const char *url=fs->Get();
287
288 while (NULL != (url = strstr(url,"http://")))
289 {
290 if (url != fs->Get() && url[-1] > 0 && isalnum(url[-1]))
291 {
292 url+=7;
293 }
294 else
295 {
296 const int soffs = (int) (url - fs->Get());
297 char tmp[512];
298 char *p=tmp;
299 while (p < (tmp+sizeof(tmp)-1) &&
300 *url && *url != ' ' && *url != ')' && *url != '\t' && *url != '"' && *url != '\'' )
301 {
302 *p++ = *url++;
303 }
304 *p=0;
305 if (strlen(tmp) >= 10 && x >= soffs && x<(url-fs->Get()))
306 {
307 ShellExecute(hwnd,"open",tmp,"","",0);
308 return 1;
309 }
310 }
311 }
312 }
313 }
314
315 case WM_LBUTTONDOWN:
316 if (CURSES_INSTANCE && CURSES_INSTANCE->m_font_w && CURSES_INSTANCE->m_font_h)
317 {
318 int x = ((short)LOWORD(lParam)) / CURSES_INSTANCE->m_font_w;
319 int y = ((short)HIWORD(lParam)) / CURSES_INSTANCE->m_font_h;
320 const int tabcnt=GetTabCount();
321 if (y==0 && tabcnt>1)
322 {
323 int tsz=COLS/tabcnt;
324 // this is duplicated in draw_top_line
325 if (tsz>128)tsz=128;
326 if (tsz<12) tsz=12;
327 SwitchTab(x/tsz,false);
328
329 return 1;
330 }
331 }
332
333 // passthrough
334 case WM_RBUTTONDOWN:
335
336 if (CURSES_INSTANCE->m_font_w && CURSES_INSTANCE->m_font_h)
337 {
338 int mousex=(short)LOWORD(lParam);
339 int mousey=(short)HIWORD(lParam);
340
341 int cx=mousex/CURSES_INSTANCE->m_font_w;
342 int cy=mousey/CURSES_INSTANCE->m_font_h;
343 if (cx > COLS) cx=COLS;
344 if (cx < 0) cx=0;
345 if (cy > LINES) cy=LINES;
346 if (cy < 0) cy=0;
347
348 m_ui_state=UI_STATE_NORMAL; // any click clears the state
349 s_mousedown[0]=cx;
350 s_mousedown[1]=cy;
351
352 int paney[2], paneh[2];
353 const int pane_divy=GetPaneDims(paney, paneh);
354
355 if (uMsg == WM_LBUTTONDOWN && m_pane_div > 0.0 && m_pane_div < 1.0 && cy == m_top_margin+pane_divy)
356 {
357 SetCapture(hwnd);
358 m_scrollcap=3;
359 return 0;
360 }
361
362 int pane=-1;
363 if (cy >= paney[0] && cy < paney[0]+paneh[0]) pane=0;
364 else if (cy >= paney[1] && cy < paney[1]+paneh[1]) pane=1;
365
366 if ((uMsg == WM_LBUTTONDOWN || uMsg == WM_LBUTTONDBLCLK) && pane >= 0 &&
367 cx >= COLS-CURSES_INSTANCE->drew_scrollbar[pane])
368 {
369 const int st=paney[pane]*CURSES_INSTANCE->m_font_h+CURSES_INSTANCE->scroll_y[pane];
370 const int sb=st+CURSES_INSTANCE->scroll_h[pane];
371
372 int prevoffs=m_paneoffs_y[pane];
373
374 if (mousey < st)
375 {
376 m_paneoffs_y[pane] -= paneh[pane];
377 if (m_paneoffs_y[pane] < 0) m_paneoffs_y[pane]=0;
378 }
379 else if (mousey < sb)
380 {
381 if (uMsg == WM_LBUTTONDOWN)
382 {
383 SetCapture(hwnd);
384 m_scrollcap=pane+1;
385 m_scrollcap_yoffs=mousey-st;
386 }
387 }
388 else
389 {
390 m_paneoffs_y[pane] += paneh[pane];
391 int maxscroll=m_text.GetSize()-paneh[pane]+4;
392 if (m_paneoffs_y[pane] > maxscroll) m_paneoffs_y[pane]=maxscroll;
393 }
394
395 if (prevoffs != m_paneoffs_y[pane])
396 {
397 draw();
398 draw_status_state();
399
400 int y=m_curs_y+paney[m_curpane]-m_paneoffs_y[m_curpane];
401 if (y >= paney[m_curpane] && y < paney[m_curpane]+paneh[m_curpane]) setCursor();
402 return 0;
403 }
404 }
405
406 if (uMsg == WM_LBUTTONDOWN) m_selecting=0;
407
408 if (pane >= 0) m_curpane=pane;
409
410 int ox=m_curs_x;
411 int oy=m_curs_y;
412
413 m_curs_x=cx+m_offs_x;
414 m_curs_y=cy+m_paneoffs_y[m_curpane]-paney[m_curpane];
415
416 bool end = (m_curs_y > m_text.GetSize()-1);
417 if (end) m_curs_y=m_text.GetSize()-1;
418 if (m_curs_y < 0) m_curs_y = 0;
419
420 WDL_FastString *s=m_text.Get(m_curs_y);
421 if (m_curs_x < 0) m_curs_x = 0;
422 const int slen = s ? WDL_utf8_get_charlen(s->Get()) : 0;
423
424 if (s && (end || m_curs_x > slen)) m_curs_x=slen;
425
426 if (uMsg == WM_LBUTTONDOWN && !!(GetAsyncKeyState(VK_SHIFT)&0x8000) &&
427 (m_curs_x != ox || m_curs_y != oy))
428 {
429 m_select_x1=ox;
430 m_select_y1=oy;
431 m_select_x2=m_curs_x;
432 m_select_y2=m_curs_y;
433 m_selecting=1;
434 }
435 else if (uMsg == WM_LBUTTONDBLCLK && s && slen)
436 {
437 if (m_curs_x < slen)
438 {
439 int x1=WDL_utf8_charpos_to_bytepos(s->Get(),m_curs_x);
440 int x2=x1+1;
441 const char* p=s->Get();
442 while (x1 > 0 && p[x1-1] > 0 && (isalnum(p[x1-1]) || p[x1-1] == '_')) --x1;
443 while (x2 < s->GetLength() && p[x2] > 0 && (isalnum(p[x2]) || p[x2] == '_')) ++x2;
444 if (x2 > x1)
445 {
446 m_select_x1=x1;
447 m_curs_x=m_select_x2=x2;
448 m_select_y1=m_select_y2=m_curs_y;
449 m_selecting=1;
450 }
451 }
452 }
453
454 draw();
455 setCursor();
456
457 if (uMsg == WM_LBUTTONDOWN)
458 {
459 SetCapture(hwnd);
460 }
461 else if (uMsg == WM_RBUTTONDOWN)
462 {
463 onRightClick(hwnd);
464 }
465 }
466 return 0;
467
468 case WM_LBUTTONUP:
469 ReleaseCapture();
470 m_scrollcap=0;
471 m_scrollcap_yoffs=0;
472 return 0;
473
474 case WM_MOUSEWHEEL:
475 if (CURSES_INSTANCE->m_font_h)
476 {
477 POINT p;
478 GetCursorPos(&p);
479 ScreenToClient(hwnd, &p);
480 p.y /= CURSES_INSTANCE->m_font_h;
481
482 int paney[2], paneh[2];
483 GetPaneDims(paney, paneh);
484 int pane=-1;
485 if (p.y >= paney[0] && p.y < paney[0]+paneh[0]) pane=0;
486 else if (p.y >= paney[1] && p.y < paney[1]+paneh[1]) pane=1;
487 if (pane < 0) pane=m_curpane;
488
489 m_paneoffs_y[pane] -= ((short)HIWORD(wParam))/20;
490
491 int maxscroll=m_text.GetSize()-paneh[pane]+4;
492 if (m_paneoffs_y[pane] > maxscroll) m_paneoffs_y[pane]=maxscroll;
493 if (m_paneoffs_y[pane] < 0) m_paneoffs_y[pane]=0;
494
495 draw();
496
497 int y=m_curs_y+paney[m_curpane]-m_paneoffs_y[m_curpane];
498 if (y >= paney[m_curpane] && y < paney[m_curpane]+paneh[m_curpane]) setCursor();
499 else draw_status_state();
500 }
501 break;
502 }
503 return 0;
504 }
505 #endif
506
507
508 WDL_CursesEditor::~WDL_CursesEditor()
509 {
510 endwin();
511 m_text.Empty(true);
512 m_undoStack.Empty(true);
513 }
514
515 int WDL_CursesEditor::init(const char *fn, const char *init_if_empty)
516 {
517 m_filename.Set(fn);
518 FILE *fh=fopenUTF8(fn,"rb");
519
520 if (!fh)
521 {
522 if (init_if_empty)
523 {
524 fh=fopenUTF8(fn,"w+b");
525 if (fh)
526 {
527 fwrite(init_if_empty,1,strlen(init_if_empty),fh);
528
529 fseek(fh,0,SEEK_SET);
530 }
531 }
532 if (!fh)
533 {
534 saveUndoState();
535 m_clean_undopos=m_undoStack_pos;
536 return 1;
537 }
538 }
539
540 loadLines(fh);
541 fclose(fh);
542
543 return 0;
544 }
545
546 int WDL_CursesEditor::reload_file(bool clearundo)
547 {
548 FILE *fh=fopenUTF8(m_filename.Get(),"rb");
549 if (fh)
550 {
551 if (!clearundo)
552 {
553 preSaveUndoState();
554 }
555 else
556 {
557 m_undoStack.Empty(true);
558 m_undoStack_pos=-1;
559 }
560
561 m_text.Empty(true);
562 loadLines(fh);
563 fclose(fh);
564
565 return 0;
566 }
567 return 1;
568 }
569
570 static void ReplaceTabs(WDL_FastString *str, int tabsz)
571 {
572 int x;
573 char s[128];
574 // replace any \t with spaces
575 int insert_sz=tabsz - 1;
576 if (insert_sz<0) insert_sz=0;
577 else if (insert_sz>128) insert_sz=128;
578
579 if (insert_sz>0) memset(s,' ',insert_sz);
580 for(x=0;x<str->GetLength();x++)
581 {
582 char *p = (char *)str->Get();
583 if (p[x] == '\t')
584 {
585 p[x] = ' ';
586 str->Insert(s,x+1,insert_sz);
587 x+=insert_sz;
588 }
589 }
590 }
591
592 void WDL_CursesEditor::loadLines(FILE *fh)
593 {
594 int crcnt = 0;
595 int tabstate = 0;
596 int tab_cnv_size=5;
597 int rdcnt=0;
598 for (;;)
599 {
600 char line[4096];
601 line[0]=0;
602 fgets(line,sizeof(line),fh);
603 if (!line[0]) break;
604
605 int l=strlen(line);
606
607 if (!rdcnt++)
608 {
609 if ((unsigned char)line[0] == 0xef &&
610 (unsigned char)line[1] == 0xbb &&
611 (unsigned char)line[2] == 0xbf)
612 {
613 // remove BOM (could track it, but currently EEL/etc don't support reading it anyway)
614 l -= 3;
615 memmove(line,line+3,l+1);
616 if (!line[0]) break;
617 }
618 }
619
620 while(l>0 && (line[l-1]=='\r' || line[l-1]=='\n'))
621 {
622 if (line[l-1] == '\r') crcnt++;
623
624 line[l-1]=0;
625 l--;
626 }
627 m_text.Add(new WDL_FastString(line));
628
629 if (tabstate>=0)
630 {
631 const char *p = line;
632 if (*p == '\t' && !tabstate) tabstate=1;
633 while (*p == '\t') p++;
634
635 int spacecnt=0;
636 while (*p == ' ') { p++; spacecnt++; }
637 if (*p == '\t' || spacecnt>7) tabstate=-1; // tab after space, or more than 7 spaces = dont try to preserve tabs
638 else if (spacecnt+1 > tab_cnv_size) tab_cnv_size = spacecnt+1;
639 }
640 }
641 if (tabstate>0)
642 {
643 m_indent_size=tab_cnv_size;
644 m_write_leading_tabs=tab_cnv_size;
645 }
646 else
647 {
648 m_write_leading_tabs=0;
649 }
650
651 int x;
652 for (x=0;x<m_text.GetSize();x++)
653 {
654 WDL_FastString *s = m_text.Get(x);
655 if (s)
656 ReplaceTabs(s,m_indent_size);
657 }
658 m_newline_mode=crcnt > m_text.GetSize()/2; // more than half of lines have crlf, then use crlf
659
660 saveUndoState();
661 m_clean_undopos=m_undoStack_pos;
662 updateLastModTime();
663 }
664
665 void WDL_CursesEditor::draw_status_state()
666 {
667 int paney[2], paneh[2];
668 const int pane_divy=GetPaneDims(paney, paneh);
669
670 attrset(COLOR_BOTTOMLINE);
671 bkgdset(COLOR_BOTTOMLINE);
672
673 int line=LINES-1;
674 const char* whichpane="";
675 if (m_pane_div > 0.0 && m_pane_div < 1.0)
676 {
677 whichpane=(!m_curpane ? "Upper pane: " : "Lower pane: ");
678 line=m_top_margin+pane_divy;
679 move(line, 0);
680 clrtoeol();
681 }
682
683 char str[512];
684 snprintf(str, sizeof(str), "%sLine %d/%d, Col %d [%s]%s",
685 whichpane, m_curs_y+1, m_text.GetSize(), m_curs_x,
686 (s_overwrite ? "OVR" : "INS"), (m_clean_undopos == m_undoStack_pos ? "" : "*"));
687
688 int len=strlen(str);
689 int x=COLS-len-1;
690 if (!*whichpane)
691 {
692 if (len < m_status_lastlen)
693 {
694 int xpos = COLS-m_status_lastlen-1;
695 if (xpos<0) xpos=0;
696 move(line,xpos);
697 while (xpos++ < x) addstr(" ");
698 }
699 m_status_lastlen = len;
700 }
701 else
702 {
703 m_status_lastlen=0;
704 }
705
706 mvaddnstr(line, x, str, len);
707 clrtoeol();
708
709 attrset(0);
710 bkgdset(0);
711
712 const int col=m_curs_x-m_offs_x;
713 line=m_curs_y+paney[m_curpane]-m_paneoffs_y[m_curpane];
714 if (line >= paney[m_curpane] && line < paney[m_curpane]+paneh[m_curpane]) move(line, col);
715 }
716
717 void WDL_CursesEditor::setCursor(int isVscroll, double ycenter)
718 {
719 int maxx=m_text.Get(m_curs_y) ? m_text.Get(m_curs_y)->GetLength() : 0;
720
721 if (isVscroll)
722 {
723 if (m_want_x >= 0) m_curs_x=m_want_x;
724 }
725 else m_want_x=-1;
726
727 if(m_curs_x>maxx)
728 {
729 if (isVscroll) m_want_x=m_curs_x;
730 m_curs_x=maxx;
731 }
732
733 int redraw=0;
734
735 if (m_curs_x < m_offs_x)
736 {
737 redraw=1;
738 m_offs_x=m_curs_x;
739 }
740 else
741 {
742 const int mw = COLS-3;
743 if (m_curs_x >= m_offs_x + mw)
744 {
745 m_offs_x=m_curs_x-mw+1;
746 redraw=1;
747 }
748 }
749
750 int paney[2], paneh[2];
751 GetPaneDims(paney, paneh);
752 int y;
753 if (ycenter >= 0.0 && ycenter < 1.0)
754 {
755 y=(int)((double)paneh[m_curpane]*ycenter);
756 m_paneoffs_y[m_curpane]=m_curs_y-y;
757 if (m_paneoffs_y[m_curpane] < 0)
758 {
759 y += m_paneoffs_y[m_curpane];
760 m_paneoffs_y[m_curpane]=0;
761 }
762 redraw=1;
763 }
764 else
765 {
766 y=m_curs_y-m_paneoffs_y[m_curpane];
767 if (y < 0)
768 {
769 m_paneoffs_y[m_curpane] += y;
770 y=0;
771 redraw=1;
772 }
773 else if (y >= paneh[m_curpane])
774 {
775 m_paneoffs_y[m_curpane] += y-paneh[m_curpane]+1;
776 y=paneh[m_curpane]-1;
777 redraw=1;
778 }
779 }
780
781 if (redraw) draw();
782
783 draw_status_state();
784
785 y += paney[m_curpane];
786 move(y, m_curs_x-m_offs_x);
787 }
788
789 void WDL_CursesEditor::draw_message(const char *str)
790 {
791 if (!CURSES_INSTANCE) return;
792
793 int l=strlen(str);
794 if (l && m_ui_state == UI_STATE_NORMAL) m_ui_state=UI_STATE_MESSAGE;
795 if (l > COLS-2) l=COLS-2;
796 if (str[0])
797 {
798 attrset(COLOR_MESSAGE);
799 bkgdset(COLOR_MESSAGE);
800 }
801 mvaddnstr(LINES-(m_bottom_margin>1?2:1),0,str,l);
802 clrtoeol();
803 if (str[0])
804 {
805 attrset(0);
806 bkgdset(0);
807 }
808
809 int paney[2], paneh[2];
810 GetPaneDims(paney, paneh);
811
812 const int col=m_curs_x-m_offs_x;
813 int line=m_curs_y+paney[m_curpane]-m_paneoffs_y[m_curpane];
814 if (line >= paney[m_curpane] && line < paney[m_curpane]+paneh[m_curpane]) move(line, col);
815 }
816
817
818 void WDL_CursesEditor::draw_line_highlight(int y, const char *p, int *c_comment_state)
819 {
820 attrset(A_NORMAL);
821 mvaddstr(y,0,p + WDL_utf8_charpos_to_bytepos(p,m_offs_x));
822 clrtoeol();
823 }
824
825 void WDL_CursesEditor::getselectregion(int &minx, int &miny, int &maxx, int &maxy)
826 {
827 if (m_select_y2 < m_select_y1)
828 {
829 miny=m_select_y2; maxy=m_select_y1;
830 minx=m_select_x2; maxx=m_select_x1;
831 }
832 else if (m_select_y1 < m_select_y2)
833 {
834 miny=m_select_y1; maxy=m_select_y2;
835 minx=m_select_x1; maxx=m_select_x2;
836 }
837 else
838 {
839 miny=maxy=m_select_y1;
840 minx=wdl_min(m_select_x1,m_select_x2);
841 maxx=wdl_max(m_select_x1,m_select_x2);
842 }
843 }
844
845 void WDL_CursesEditor::doDrawString(int y, int line_n, const char *p, int *c_comment_state)
846 {
847 draw_line_highlight(y,p,c_comment_state);
848
849 if (m_selecting)
850 {
851 int miny,maxy,minx,maxx;
852 getselectregion(minx,miny,maxx,maxy);
853
854 if (line_n >= miny && line_n <= maxy && (miny != maxy || minx < maxx))
855 {
856 minx-=m_offs_x;
857 maxx-=m_offs_x;
858
859 const int cols = COLS;
860
861 if (line_n > miny) minx=0;
862 if (line_n < maxy) maxx=cols;
863
864 if (minx<0)minx=0;
865 if (minx > cols) minx=cols;
866 if (maxx > cols) maxx=cols;
867
868 if (maxx > minx)
869 {
870 attrset(COLOR_SELECTION);
871 p += WDL_utf8_charpos_to_bytepos(p,m_offs_x+minx);
872 mvaddnstr(y,minx, p, WDL_utf8_charpos_to_bytepos(p,maxx-minx));
873 attrset(A_NORMAL);
874 }
875 else if (maxx==minx && !*p)
876 {
877 attrset(COLOR_SELECTION);
878 mvaddstr(y,minx," ");
879 attrset(A_NORMAL);
880 }
881 }
882 }
883 }
884
885 int WDL_CursesEditor::GetCommentStateForLineStart(int line) // pass current line/col, updates with previous interesting point, returns true if start of comment, or false if end of previous comment
886 {
887 return 0;
888 }
889
890
891 void WDL_CursesEditor::draw(int lineidx)
892 {
893 if (m_top_margin != 0) m_top_margin = GetTabCount()>1 ? 2 : 1;
894
895 int paney[2], paneh[2];
896 const int pane_divy=GetPaneDims(paney, paneh);
897
898 #ifdef WDL_IS_FAKE_CURSES
899 if (m_cursesCtx)
900 {
901 CURSES_INSTANCE->offs_y[0]=m_paneoffs_y[0];
902 CURSES_INSTANCE->offs_y[1]=m_paneoffs_y[1];
903 CURSES_INSTANCE->div_y=pane_divy;
904 CURSES_INSTANCE->tot_y=m_text.GetSize();
905
906 CURSES_INSTANCE->scrollbar_topmargin = m_top_margin;
907 CURSES_INSTANCE->scrollbar_botmargin = m_bottom_margin;
908 }
909 #endif
910
911 attrset(A_NORMAL);
912
913 if (lineidx >= 0)
914 {
915 int comment_state = GetCommentStateForLineStart(lineidx);
916 WDL_FastString *s=m_text.Get(lineidx);
917 if (s)
918 {
919 int y=lineidx-m_paneoffs_y[0];
920 if (y >= 0 && y < paneh[0])
921 {
922 doDrawString(paney[0]+y, lineidx, s->Get(), &comment_state);
923 }
924 y=lineidx-m_paneoffs_y[1];
925 if (y >= 0 && y < paneh[1])
926 {
927 doDrawString(paney[1]+y, lineidx, s->Get(), &comment_state);
928 }
929 }
930 return;
931 }
932
933 __curses_invalidatefull((win32CursesCtx*)m_cursesCtx,false);
934
935 draw_top_line();
936
937 attrset(A_NORMAL);
938 bkgdset(A_NORMAL);
939
940 move(m_top_margin,0);
941 clrtoeol();
942
943 m_status_lastlen=0;
944
945 int pane, i;
946 for (pane=0; pane < 2; ++pane)
947 {
948 int ln=m_paneoffs_y[pane];
949 int y=paney[pane];
950 int h=paneh[pane];
951
952 int comment_state=GetCommentStateForLineStart(ln);
953
954 for(i=0; i < h; ++i, ++ln, ++y)
955 {
956 WDL_FastString *s=m_text.Get(ln);
957 if (!s)
958 {
959 move(y,0);
960 clrtoeol();
961 }
962 else
963 {
964 doDrawString(y,ln,s->Get(),&comment_state);
965 }
966 }
967 }
968
969 attrset(COLOR_BOTTOMLINE);
970 bkgdset(COLOR_BOTTOMLINE);
971
972 if (m_bottom_margin>0)
973 {
974 move(LINES-1, 0);
975 #define BOLD(x) { attrset(COLOR_BOTTOMLINE|A_BOLD); addstr(x); attrset(COLOR_BOTTOMLINE&~A_BOLD); }
976 if (m_selecting)
977 {
978 mvaddstr(LINES-1,0,"SELECTING ESC:cancel " CONTROL_KEY_NAME "+(");
979 BOLD("C"); addstr("opy ");
980 BOLD("X"); addstr(":cut ");
981 BOLD("V"); addstr(":paste)");
982 }
983 else
984 {
985 mvaddstr(LINES-1, 0, CONTROL_KEY_NAME "+(");
986
987 if (m_pane_div <= 0.0 || m_pane_div >= 1.0)
988 {
989 BOLD("P"); addstr("ane ");
990 }
991 else
992 {
993 BOLD("O"); addstr("therpane ");
994 addstr("no"); BOLD("P"); addstr("anes ");
995 }
996 BOLD("F"); addstr("ind ");
997 draw_bottom_line();
998 addstr(")");
999 }
1000 #undef BOLD
1001 clrtoeol();
1002 }
1003
1004 attrset(0);
1005 bkgdset(0);
1006
1007 __curses_invalidatefull((win32CursesCtx*)m_cursesCtx,true);
1008 }
1009
1010 void WDL_CursesEditor::draw_bottom_line()
1011 {
1012 // implementers add key commands here
1013 }
1014
1015 static const char *countLeadingTabs(const char *p, int *ntabs, int tabsz)
1016 {
1017 if (tabsz>0) while (*p)
1018 {
1019 int i;
1020 for (i=0;i<tabsz;i++) if (p[i]!=' ') return p;
1021 p+=tabsz;
1022 (*ntabs) += 1;
1023 }
1024 return p;
1025 }
1026
1027 int WDL_CursesEditor::updateFile()
1028 {
1029 FILE *fp=fopenUTF8(m_filename.Get(),"wb");
1030 if (!fp) return 1;
1031 int x;
1032 for (x = 0; x < m_text.GetSize(); x ++)
1033 {
1034 WDL_FastString *s = m_text.Get(x);
1035 if (s)
1036 {
1037 int tabcnt=0;
1038 const char *p = countLeadingTabs(s->Get(),&tabcnt,m_write_leading_tabs);
1039 while (tabcnt-->0) fputc('\t',fp);
1040 fwrite(p,1,strlen(p),fp);
1041 if (m_newline_mode==1) fputc('\r',fp);
1042 fputc('\n',fp);
1043 }
1044 }
1045 fclose(fp);
1046 sync();
1047
1048 updateLastModTime();
1049 m_clean_undopos = m_undoStack_pos;
1050
1051 return 0;
1052 }
1053
1054 void WDL_CursesEditor::updateLastModTime()
1055 {
1056 struct stat srcstat;
1057 if (!statUTF8(m_filename.Get(), &srcstat))
1058 {
1059 #ifndef __APPLE__
1060 m_filelastmod = srcstat.st_mtime;
1061 #else
1062 m_filelastmod = srcstat.st_mtimespec.tv_sec;
1063 #endif
1064 }
1065 else
1066 {
1067 m_filelastmod = 0;
1068 }
1069 }
1070
1071 void WDL_CursesEditor::indentSelect(int amt)
1072 {
1073 if (m_selecting) // remove selected text
1074 {
1075 int miny,maxy,minx,maxx;
1076 int x;
1077 getselectregion(minx,miny,maxx,maxy);
1078 if (maxy >= miny)
1079 {
1080 m_select_x1 = 0;
1081 m_select_y1 = miny;
1082 m_select_y2 = maxy;
1083 m_select_x2 = maxx;
1084 if (maxx<1 && maxy>miny) maxy--; // exclude empty final line
1085
1086 if (m_curs_y >= miny && m_curs_y <=maxy)
1087 {
1088 m_curs_x += amt;
1089 if (m_curs_x<0)m_curs_x=0;
1090 }
1091
1092 if (amt<0)
1093 {
1094 int minspc=-amt;
1095 for (x = miny; x <= maxy; x ++)
1096 {
1097 WDL_FastString *s=m_text.Get(x);
1098 if (s)
1099 {
1100 int a=0;
1101 while (a<minspc && s->Get()[a]== ' ') a++;
1102 minspc = a;
1103 }
1104 }
1105 if (minspc>0 && minspc < -amt) amt = -minspc;
1106 }
1107
1108 for (x = miny; x <= maxy; x ++)
1109 {
1110 WDL_FastString *s=m_text.Get(x);
1111 if (s)
1112 {
1113 if (amt>0)
1114 {
1115 int a;
1116 for(a=0;a<amt;a+=16)
1117 s->Insert(" ",0,wdl_min(amt-a,16));
1118 }
1119 else if (amt<0)
1120 {
1121 int a=0;
1122 while (a<-amt && s->Get()[a]== ' ') a++;
1123 s->DeleteSub(0,a);
1124 }
1125 }
1126 if (x==m_select_y2) m_select_x2 = s ? s->GetLength() : 0;
1127 }
1128 }
1129 }
1130 }
1131
1132 void WDL_CursesEditor::removeSelect()
1133 {
1134 if (m_selecting) // remove selected text
1135 {
1136 int miny,maxy,minx,maxx;
1137 int x;
1138 getselectregion(minx,miny,maxx,maxy);
1139 m_curs_x = minx;
1140 m_curs_y = miny;
1141 if (m_curs_y < 0) m_curs_y=0;
1142
1143 if (minx != maxx|| miny != maxy)
1144 {
1145 int fht=0,lht=0;
1146 for (x = miny; x <= maxy; x ++)
1147 {
1148 WDL_FastString *s=m_text.Get(x);
1149 if (s)
1150 {
1151 const int sx=x == miny ? WDL_utf8_charpos_to_bytepos(s->Get(),minx) : 0;
1152 const int ex=x == maxy ? WDL_utf8_charpos_to_bytepos(s->Get(),maxx) : s->GetLength();
1153
1154 if (x != maxy && sx == 0 && ex == s->GetLength()) // remove entire line
1155 {
1156 m_text.Delete(x,true);
1157 if (x==miny) miny--;
1158 x--;
1159 maxy--;
1160 }
1161 else { if (x==miny) fht=1; if (x == maxy) lht=1; s->DeleteSub(sx,ex-sx); }
1162 }
1163 }
1164 if (fht && lht && miny+1 == maxy)
1165 {
1166 m_text.Get(miny)->Append(m_text.Get(maxy)->Get());
1167 m_text.Delete(maxy,true);
1168 }
1169
1170 }
1171 m_selecting=0;
1172 if (m_curs_y >= m_text.GetSize())
1173 {
1174 m_curs_y = m_text.GetSize();
1175 m_text.Add(new WDL_FastString);
1176 }
1177 }
1178
1179 }
1180
1181 static const char *skip_indent(const char *tstr, int skipsz)
1182 {
1183 while (*tstr == ' ' && skipsz-->0) tstr++;
1184 return tstr;
1185 }
1186
1187 static WDL_FastString *newIndentedFastString(const char *tstr, int indent_to_pos)
1188 {
1189 WDL_FastString *s=new WDL_FastString;
1190 if (indent_to_pos>=0)
1191 {
1192 int x;
1193 for (x=0;x<indent_to_pos;x++) s->Append(" ");
1194 }
1195 s->Append(tstr);
1196 return s;
1197
1198 }
1199
1200 void WDL_CursesEditor::highlight_line(int line)
1201 {
1202 if (line >= 0 && line <= m_text.GetSize())
1203 {
1204 bool nosel=false;
1205 if (line == m_text.GetSize()) { line--; nosel=true; }
1206
1207 m_curs_x=0;
1208 m_curs_y=line;
1209
1210 WDL_FastString* s=m_text.Get(line);
1211 if (s && s->GetLength())
1212 {
1213 if (nosel) m_curs_x = WDL_utf8_get_charlen(s->Get());
1214 else
1215 {
1216 m_select_x1=0;
1217 m_select_x2=WDL_utf8_get_charlen(s->Get());
1218 m_select_y1=m_select_y2=m_curs_y;
1219 m_selecting=1;
1220 }
1221 draw();
1222 }
1223
1224 setCursor();
1225 }
1226 }
1227
1228 void WDL_CursesEditor::runSearch()
1229 {
1230 if (s_search_string[0])
1231 {
1232 int wrapflag=0,found=0;
1233 int line;
1234 int numlines = m_text.GetSize();
1235 int startx=m_curs_x+1;
1236
1237 const int srchlen=strlen(s_search_string);
1238 for (line = m_curs_y; line < numlines && !found; line ++)
1239 {
1240 WDL_FastString *tl = m_text.Get(line);
1241 if (startx && tl) startx = WDL_utf8_charpos_to_bytepos(tl->Get(),startx);
1242 const char *p;
1243
1244 if (tl && (p=tl->Get()))
1245 {
1246 const int linelen = tl->GetLength();
1247 for (; startx <= linelen-srchlen; startx++)
1248 if (!strnicmp(p+startx,s_search_string,srchlen))
1249 {
1250 m_select_y1=m_select_y2=m_curs_y=line;
1251 m_select_x1=m_curs_x=WDL_utf8_bytepos_to_charpos(p,startx);
1252 m_select_x2=m_curs_x+WDL_utf8_get_charlen(s_search_string);
1253 m_selecting=1;
1254 found=1;
1255 break;
1256 }
1257 }
1258
1259
1260 startx=0;
1261 }
1262 if (!found && (m_curs_y>0 || m_curs_x > 0))
1263 {
1264 wrapflag=1;
1265 numlines = wdl_min(m_curs_y+1,numlines);
1266 for (line = 0; line < numlines && !found; line ++)
1267 {
1268 WDL_FastString *tl = m_text.Get(line);
1269 if (startx && tl) startx = WDL_utf8_charpos_to_bytepos(tl->Get(),startx);
1270
1271 const char *p;
1272
1273 if (tl && (p=tl->Get()))
1274 {
1275 const int linelen = tl->GetLength();
1276 for (; startx <= linelen-srchlen; startx++)
1277 if (!strnicmp(p+startx,s_search_string,srchlen))
1278 {
1279 m_select_y1=m_select_y2=m_curs_y=line;
1280 m_select_x1=m_curs_x=WDL_utf8_bytepos_to_charpos(p,startx);
1281 m_select_x2=m_curs_x+WDL_utf8_get_charlen(s_search_string);
1282 m_selecting=1;
1283 found=1;
1284 break;
1285 }
1286 }
1287 startx=0;
1288 }
1289 }
1290 if (found)
1291 {
1292 draw();
1293 setCursor();
1294 char buf[512];
1295 snprintf(buf,sizeof(buf),"Found %s'%s' " CONTROL_KEY_NAME "+G:next",wrapflag?"(wrapped) ":"",s_search_string);
1296 draw_message(buf);
1297 return;
1298 }
1299 }
1300
1301 draw();
1302 setCursor();
1303 char buf[512];
1304 if (s_search_string[0]) snprintf(buf,sizeof(buf),"String '%s' not found",s_search_string);
1305 else lstrcpyn_safe(buf,"No search string",sizeof(buf));
1306 draw_message(buf);
1307 }
1308
1309 static int categorizeCharForWordNess(int c)
1310 {
1311 if (c >= 0 && c < 256)
1312 {
1313 if (isspace(c)) return 0;
1314 if (isalnum(c) || c == '_') return 1;
1315 if (c == ';') return 2; // I prefer this, since semicolons are somewhat special
1316 }
1317 return 3;
1318 }
1319
1320 #define CTRL_KEY_DOWN (GetAsyncKeyState(VK_CONTROL)&0x8000)
1321 #define SHIFT_KEY_DOWN (GetAsyncKeyState(VK_SHIFT)&0x8000)
1322 #define ALT_KEY_DOWN (GetAsyncKeyState(VK_MENU)&0x8000)
1323
1324
1325 void WDL_CursesEditor::getLinesFromClipboard(WDL_FastString &buf, WDL_PtrList<const char> &lines)
1326 {
1327 #ifdef WDL_IS_FAKE_CURSES
1328 if (CURSES_INSTANCE)
1329 {
1330 HANDLE h;
1331 OpenClipboard(CURSES_INSTANCE->m_hwnd);
1332 #ifdef CF_UNICODETEXT
1333 h=GetClipboardData(CF_UNICODETEXT);
1334 if (h)
1335 {
1336 wchar_t *t=(wchar_t *)GlobalLock(h);
1337 int s=(int)(GlobalSize(h)/2);
1338 while (s-- > 0)
1339 {
1340 char b[32];
1341 if (!*t) break;
1342 WDL_MakeUTFChar(b,*t++,sizeof(b));
1343 buf.Append(b);
1344 }
1345
1346 GlobalUnlock(t);
1347 }
1348
1349 #endif
1350 if (!buf.GetLength())
1351 {
1352 h=GetClipboardData(CF_TEXT);
1353 if (h)
1354 {
1355 char *t=(char *)GlobalLock(h);
1356 int s=(int)(GlobalSize(h));
1357 buf.Set(t,s);
1358 GlobalUnlock(t);
1359 }
1360 }
1361 CloseClipboard();
1362 }
1363 else
1364 #endif
1365 {
1366 buf.Set(s_fake_clipboard.Get());
1367 }
1368
1369 if (buf.Get() && buf.Get()[0])
1370 {
1371 ReplaceTabs(&buf,m_indent_size);
1372
1373 char *src=(char*)buf.Get();
1374 while (*src)
1375 {
1376 char *seek=src;
1377 while (*seek && *seek != '\r' && *seek != '\n') seek++;
1378 char hadclr=*seek;
1379 if (*seek) *seek++=0;
1380 lines.Add(src);
1381
1382 if (hadclr == '\r' && *seek == '\n') seek++;
1383
1384 if (hadclr && !*seek)
1385 {
1386 lines.Add("");
1387 }
1388 src=seek;
1389 }
1390 }
1391 }
1392
1393
1394 int WDL_CursesEditor::onChar(int c)
1395 {
1396 // multitab
1397 if (m_ui_state == UI_STATE_MESSAGE)
1398 {
1399 m_ui_state=UI_STATE_NORMAL;
1400 draw();
1401 setCursor();
1402 }
1403
1404 if (m_ui_state == UI_STATE_NORMAL && !SHIFT_KEY_DOWN && !ALT_KEY_DOWN && c =='W'-'A'+1)
1405 {
1406 if (GetTab(0) == this) return 0; // first in list = do nothing
1407
1408 if (IsDirty())
1409 {
1410 m_ui_state=UI_STATE_SAVE_ON_CLOSE;
1411 attrset(COLOR_MESSAGE);
1412 bkgdset(COLOR_MESSAGE);
1413 mvaddstr(LINES-1,0,"Save file before closing (y/N)? ");
1414 clrtoeol();
1415 attrset(0);
1416 bkgdset(0);
1417 }
1418 else
1419 {
1420 CloseCurrentTab();
1421
1422 delete this;
1423 // context no longer valid!
1424 return 1;
1425 }
1426 return 0;
1427 }
1428
1429 if (m_ui_state == UI_STATE_SAVE_ON_CLOSE)
1430 {
1431 if (c>=0 && (isalnum(c) || isprint(c) || c==27))
1432 {
1433 if (c == 27)
1434 {
1435 m_ui_state=UI_STATE_NORMAL;
1436 draw();
1437 draw_message("Cancelled close of file.");
1438 setCursor();
1439 return 0;
1440 }
1441 if (toupper(c) == 'N' || toupper(c) == 'Y')
1442 {
1443 if (toupper(c) == 'Y')
1444 {
1445 if(updateFile())
1446 {
1447 m_ui_state=UI_STATE_NORMAL;
1448 draw();
1449 draw_message("Error writing file, changes not saved!");
1450 setCursor();
1451 return 0;
1452 }
1453 }
1454 CloseCurrentTab();
1455
1456 delete this;
1457 // this no longer valid, return 1 to avoid future calls in onChar()
1458
1459 return 1;
1460 }
1461 }
1462 return 0;
1463 }
1464 else if (m_ui_state == UI_STATE_SAVE_AS_NEW)
1465 {
1466 if (c>=0 && (isalnum(c) || isprint(c) || c==27 || c == '\r' || c=='\n'))
1467 {
1468 m_ui_state=UI_STATE_NORMAL;
1469 if (toupper(c) == 'N' || c == 27)
1470 {
1471 draw();
1472 draw_message("Cancelled create new file.");
1473 setCursor();
1474 return 0;
1475 }
1476
1477 AddTab(m_newfn.Get());
1478 }
1479 return 0;
1480 }
1481
1482 if ((c==27 || c==29 || (c >= KEY_F1 && c<=KEY_F10)) && CTRL_KEY_DOWN)
1483 {
1484 int idx=c-KEY_F1;
1485 bool rel=true;
1486 if (c==27) idx=-1;
1487 else if (c==29) idx=1;
1488 else rel=false;
1489 SwitchTab(idx,rel);
1490
1491 return 1;
1492 }
1493 // end multitab
1494
1495 if (m_ui_state == UI_STATE_SEARCH || m_ui_state == UI_STATE_SEARCH2)
1496 {
1497 switch (c)
1498 {
1499 case '\r': case '\n':
1500 m_ui_state=UI_STATE_NORMAL;
1501 runSearch();
1502 break;
1503 case 27:
1504 m_ui_state=UI_STATE_NORMAL;
1505 draw();
1506 setCursor();
1507 draw_message("Find cancelled.");
1508 break;
1509 case KEY_BACKSPACE:
1510 if (s_search_string[0])
1511 {
1512 char *p = s_search_string;
1513 if (*p) for (;;)
1514 {
1515 int sz=wdl_utf8_parsechar(p,NULL);
1516 if (!p[sz])
1517 {
1518 *p=0;
1519 break;
1520 }
1521 p+=sz;
1522 }
1523 }
1524 m_ui_state=UI_STATE_SEARCH2;
1525 break;
1526 case KEY_IC:
1527 if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN) break;
1528 case 'V'-'A'+1:
1529
1530 {
1531 WDL_PtrList<const char> lines;
1532 WDL_FastString buf;
1533 getLinesFromClipboard(buf,lines);
1534 if (lines.Get(0))
1535 {
1536 if (m_ui_state==UI_STATE_SEARCH)
1537 {
1538 s_search_string[0]=0;
1539 m_ui_state=UI_STATE_SEARCH2;
1540 }
1541 lstrcatn(s_search_string,lines.Get(0),sizeof(s_search_string));
1542 }
1543 }
1544 break;
1545 default:
1546 if (VALIDATE_TEXT_CHAR(c))
1547 {
1548 int l=m_ui_state == UI_STATE_SEARCH ? 0 : strlen(s_search_string);
1549 m_ui_state = UI_STATE_SEARCH2;
1550 if (l < (int)sizeof(s_search_string)-8)
1551 {
1552 WDL_MakeUTFChar(s_search_string+l,c,8);
1553 }
1554 }
1555 break;
1556 }
1557 if (m_ui_state == UI_STATE_SEARCH || m_ui_state == UI_STATE_SEARCH2)
1558 {
1559 attrset(COLOR_MESSAGE);
1560 bkgdset(COLOR_MESSAGE);
1561 mvaddstr(LINES-1,29,s_search_string);
1562 clrtoeol();
1563 attrset(0);
1564 bkgdset(0);
1565 }
1566 return 0;
1567 }
1568 if (c==KEY_DOWN || c==KEY_UP || c==KEY_PPAGE||c==KEY_NPAGE || c==KEY_RIGHT||c==KEY_LEFT||c==KEY_HOME||c==KEY_END)
1569 {
1570 if (SHIFT_KEY_DOWN)
1571 {
1572 if (!m_selecting)
1573 {
1574 m_select_x2=m_select_x1=m_curs_x; m_select_y2=m_select_y1=m_curs_y;
1575 m_selecting=1;
1576 }
1577 }
1578 else if (m_selecting) { m_selecting=0; draw(); }
1579 }
1580
1581 switch(c)
1582 {
1583 case 'O'-'A'+1:
1584 if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN)
1585 {
1586 if (m_pane_div <= 0.0 || m_pane_div >= 1.0)
1587 {
1588 onChar('P'-'A'+1);
1589 }
1590 if (m_pane_div > 0.0 && m_pane_div < 1.0)
1591 {
1592 m_curpane=!m_curpane;
1593 draw();
1594 draw_status_state();
1595 int paney[2], paneh[2];
1596 GetPaneDims(paney, paneh);
1597 if (m_curs_y-m_paneoffs_y[m_curpane] < 0) m_curs_y=m_paneoffs_y[m_curpane];
1598 else if (m_curs_y-m_paneoffs_y[m_curpane] >= paneh[m_curpane]) m_curs_y=paneh[m_curpane]+m_paneoffs_y[m_curpane]-1;
1599 setCursor();
1600 }
1601 }
1602 break;
1603 case 'P'-'A'+1:
1604 if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN)
1605 {
1606 if (m_pane_div <= 0.0 || m_pane_div >= 1.0)
1607 {
1608 m_pane_div=0.5;
1609 m_paneoffs_y[1]=m_paneoffs_y[0];
1610 }
1611 else
1612 {
1613 m_pane_div=1.0;
1614 if (m_curpane) m_paneoffs_y[0]=m_paneoffs_y[1];
1615 m_curpane=0;
1616 }
1617 draw();
1618 draw_status_state();
1619
1620 int paney[2], paneh[2];
1621 GetPaneDims(paney, paneh);
1622 setCursor();
1623 }
1624 break;
1625
1626 case 407:
1627 case 'Z'-'A'+1:
1628 if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN)
1629 {
1630 if (m_undoStack_pos > 0)
1631 {
1632 m_undoStack_pos--;
1633 loadUndoState(m_undoStack.Get(m_undoStack_pos),1);
1634 draw();
1635 setCursor();
1636 char buf[512];
1637 snprintf(buf,sizeof(buf),"Undid action - %d items in undo buffer",m_undoStack_pos);
1638 draw_message(buf);
1639 }
1640 else
1641 {
1642 draw_message("Can't Undo");
1643 }
1644 break;
1645 }
1646 // fall through
1647 case 'Y'-'A'+1:
1648 if ((c == 'Z'-'A'+1 || !SHIFT_KEY_DOWN) && !ALT_KEY_DOWN)
1649 {
1650 if (m_undoStack_pos < m_undoStack.GetSize()-1)
1651 {
1652 m_undoStack_pos++;
1653 loadUndoState(m_undoStack.Get(m_undoStack_pos),0);
1654 draw();
1655 setCursor();
1656 char buf[512];
1657 snprintf(buf,sizeof(buf),"Redid action - %d items in redo buffer",m_undoStack.GetSize()-m_undoStack_pos-1);
1658 draw_message(buf);
1659 }
1660 else
1661 {
1662 draw_message("Can't Redo");
1663 }
1664 }
1665 break;
1666 case KEY_IC:
1667 if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN)
1668 {
1669 s_overwrite=!s_overwrite;
1670 setCursor();
1671 break;
1672 }
1673 // fall through
1674 case 'V'-'A'+1:
1675 if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN)
1676 {
1677 // generate a m_clipboard using win32 clipboard data
1678 WDL_PtrList<const char> lines;
1679 WDL_FastString buf;
1680 getLinesFromClipboard(buf,lines);
1681
1682 if (lines.GetSize())
1683 {
1684 removeSelect();
1685 // insert lines at m_curs_y,m_curs_x
1686 if (m_curs_y > m_text.GetSize()) m_curs_y=m_text.GetSize();
1687 if (m_curs_y < 0) m_curs_y=0;
1688
1689 preSaveUndoState();
1690 WDL_FastString poststr;
1691 int x;
1692 int indent_to_pos = -1;
1693 int skip_source_indent=0; // number of characters of whitespace to (potentially) ignore when pasting
1694
1695 for (x = 0; x < lines.GetSize(); x ++)
1696 {
1697 WDL_FastString *str=m_text.Get(m_curs_y);
1698 const char *tstr=lines.Get(x);
1699 if (!tstr) tstr="";
1700 if (!x)
1701 {
1702 if (str)
1703 {
1704 int bytepos = WDL_utf8_charpos_to_bytepos(str->Get(),m_curs_x);
1705
1706 if (bytepos < 0) bytepos=0;
1707 int tmp=str->GetLength();
1708 if (bytepos > tmp) bytepos=tmp;
1709
1710 poststr.Set(str->Get()+bytepos);
1711 str->SetLen(bytepos);
1712
1713 const char *p = str->Get();
1714 while (*p == ' ' || *p == '\t') p++;
1715 if (!*p && p > str->Get()) // if all whitespace leading up to this
1716 {
1717 if (bytepos > 0)
1718 {
1719 int i;
1720 skip_source_indent=1024;
1721 for (i = 0; skip_source_indent > 0 && i < lines.GetSize(); i ++)
1722 {
1723 int a=0;
1724 const char *p = lines.Get(i);
1725 while (a < skip_source_indent && p[a] == ' ') a++;
1726 if (a < skip_source_indent && p[a]) skip_source_indent=a;
1727 }
1728 }
1729
1730 indent_to_pos = bytepos;
1731 }
1732
1733 str->Append(skip_indent(tstr,skip_source_indent));
1734 }
1735 else
1736 {
1737 m_text.Insert(m_curs_y,(str=new WDL_FastString(skip_indent(tstr,skip_source_indent))));
1738 }
1739
1740 if (lines.GetSize() > 1)
1741 {
1742 m_curs_y++;
1743 }
1744 else
1745 {
1746 m_curs_x = WDL_utf8_get_charlen(str->Get());
1747 str->Append(poststr.Get());
1748 }
1749 }
1750 else if (x == lines.GetSize()-1)
1751 {
1752 WDL_FastString *s=newIndentedFastString(skip_indent(tstr,skip_source_indent),indent_to_pos);
1753 m_curs_x = WDL_utf8_get_charlen(s->Get());
1754 s->Append(poststr.Get());
1755 m_text.Insert(m_curs_y,s);
1756 }
1757 else
1758 {
1759 m_text.Insert(m_curs_y,newIndentedFastString(skip_indent(tstr,skip_source_indent),indent_to_pos));
1760 m_curs_y++;
1761 }
1762 }
1763 draw();
1764 setCursor();
1765 draw_message("Pasted");
1766 saveUndoState();
1767 }
1768 else
1769 {
1770 setCursor();
1771 draw_message("Clipboard empty");
1772 }
1773 }
1774 break;
1775
1776 case KEY_DC:
1777 if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN)
1778 {
1779 WDL_FastString *s;
1780 if (m_selecting)
1781 {
1782 preSaveUndoState();
1783 removeSelect();
1784 draw();
1785 saveUndoState();
1786 setCursor();
1787 }
1788 else if ((s=m_text.Get(m_curs_y)))
1789 {
1790 const int xbyte = WDL_utf8_charpos_to_bytepos(s->Get(),m_curs_x);
1791 if (xbyte < s->GetLength())
1792 {
1793 preSaveUndoState();
1794
1795 const int xbytesz=WDL_utf8_charpos_to_bytepos(s->Get()+xbyte,1);
1796 bool hadCom = LineCanAffectOtherLines(s->Get(),xbyte,xbytesz);
1797 s->DeleteSub(xbyte,xbytesz);
1798 if (!hadCom) hadCom = LineCanAffectOtherLines(s->Get(),xbyte,0);
1799 draw(hadCom ? -1 : m_curs_y);
1800 saveUndoState();
1801 setCursor();
1802 }
1803 else // append next line to us
1804 {
1805 if (m_curs_y < m_text.GetSize()-1)
1806 {
1807 preSaveUndoState();
1808
1809 WDL_FastString *nl=m_text.Get(m_curs_y+1);
1810 if (nl)
1811 {
1812 s->Append(nl->Get());
1813 }
1814 m_text.Delete(m_curs_y+1,true);
1815
1816 draw();
1817 saveUndoState();
1818 setCursor();
1819 }
1820 }
1821 }
1822 break;
1823 }
1824 case 'C'-'A'+1:
1825 case 'X'-'A'+1:
1826 if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN && m_selecting)
1827 {
1828 if (c!= 'C'-'A'+1) m_selecting=0;
1829 int miny,maxy,minx,maxx;
1830 int x;
1831 getselectregion(minx,miny,maxx,maxy);
1832 const char *status="";
1833 char statusbuf[512];
1834
1835 if (minx != maxx|| miny != maxy)
1836 {
1837 int bytescopied=0;
1838 s_fake_clipboard.Set("");
1839
1840 int lht=0,fht=0;
1841 if (c != 'C'-'A'+1) preSaveUndoState();
1842
1843 for (x = miny; x <= maxy; x ++)
1844 {
1845 WDL_FastString *s=m_text.Get(x);
1846 if (s)
1847 {
1848 const char *str=s->Get();
1849 const int sx=x == miny ? WDL_utf8_charpos_to_bytepos(s->Get(),minx) : 0;
1850 const int ex=x == maxy ? WDL_utf8_charpos_to_bytepos(s->Get(),maxx) : s->GetLength();
1851
1852 bytescopied += ex-sx + (x!=maxy);
1853 if (s_fake_clipboard.Get() && s_fake_clipboard.Get()[0]) s_fake_clipboard.Append("\r\n");
1854
1855 const int oldlen = s_fake_clipboard.GetLength();
1856 s_fake_clipboard.Append(ex-sx?str+sx:"",ex-sx);
1857 if (m_write_leading_tabs>0 && sx==0 && oldlen < s_fake_clipboard.GetLength())
1858 {
1859 const char *p = s_fake_clipboard.Get() + oldlen;
1860 int nt=0;
1861 const char *sp = countLeadingTabs(p,&nt,m_write_leading_tabs);
1862 if (nt && sp > p)
1863 {
1864 s_fake_clipboard.DeleteSub(oldlen,(int)(sp-p));
1865 while (nt>0)
1866 {
1867 int c = nt;
1868 if (c > 8) c=8;
1869 nt -= c;
1870 s_fake_clipboard.Insert("\t\t\t\t\t\t\t\t",oldlen,c);
1871 }
1872 }
1873 }
1874
1875 if (c != 'C'-'A'+1)
1876 {
1877 if (sx == 0 && ex == s->GetLength()) // remove entire line
1878 {
1879 m_text.Delete(x,true);
1880 if (x==miny) miny--;
1881 x--;
1882 maxy--;
1883 }
1884 else { if (x==miny) fht=1; if (x == maxy) lht=1; s->DeleteSub(sx,ex-sx); }
1885 }
1886 }
1887 }
1888 if (fht && lht && miny+1 == maxy)
1889 {
1890 m_text.Get(miny)->Append(m_text.Get(maxy)->Get());
1891 m_text.Delete(maxy,true);
1892 }
1893 if (c != 'C'-'A'+1)
1894 {
1895 m_curs_y=miny;
1896 if (m_curs_y < 0) m_curs_y=0;
1897 m_curs_x=minx;
1898 saveUndoState();
1899 snprintf(statusbuf,sizeof(statusbuf),"Cut %d bytes",bytescopied);
1900 }
1901 else
1902 snprintf(statusbuf,sizeof(statusbuf),"Copied %d bytes",bytescopied);
1903
1904 #ifdef WDL_IS_FAKE_CURSES
1905 if (CURSES_INSTANCE)
1906 {
1907 #ifdef CF_UNICODETEXT
1908 const int l=(WDL_utf8_get_charlen(s_fake_clipboard.Get())+1)*sizeof(wchar_t);
1909 HANDLE h=GlobalAlloc(GMEM_MOVEABLE,l);
1910 wchar_t *t=(wchar_t*)GlobalLock(h);
1911 if (t)
1912 {
1913 WDL_MBtoWideStr(t,s_fake_clipboard.Get(),l);
1914 GlobalUnlock(h);
1915 }
1916 OpenClipboard(CURSES_INSTANCE->m_hwnd);
1917 EmptyClipboard();
1918 SetClipboardData(CF_UNICODETEXT,h);
1919 #else
1920 int l=s_fake_clipboard.GetLength()+1;
1921 HANDLE h=GlobalAlloc(GMEM_MOVEABLE,l);
1922 void *t=GlobalLock(h);
1923 if (t)
1924 {
1925 memcpy(t,s_fake_clipboard.Get(),l);
1926 GlobalUnlock(h);
1927 }
1928 OpenClipboard(CURSES_INSTANCE->m_hwnd);
1929 EmptyClipboard();
1930 SetClipboardData(CF_TEXT,h);
1931 #endif
1932 CloseClipboard();
1933 }
1934 #endif
1935
1936 status=statusbuf;
1937 }
1938 else status="No selection";
1939
1940 draw();
1941 setCursor();
1942 draw_message(status);
1943 }
1944 break;
1945 case 'A'-'A'+1:
1946 if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN)
1947 {
1948 m_selecting=1;
1949 m_select_x1=0;
1950 m_select_y1=0;
1951 m_select_y2=m_text.GetSize()-1;
1952 m_select_x2=0;
1953 if (m_text.Get(m_select_y2))
1954 m_select_x2=m_text.Get(m_select_y2)->GetLength();
1955 draw();
1956 setCursor();
1957 }
1958 break;
1959 case 27:
1960 if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN && m_selecting)
1961 {
1962 m_selecting=0;
1963 draw();
1964 setCursor();
1965 break;
1966 }
1967 break;
1968 case KEY_F3:
1969 case 'G'-'A'+1:
1970 if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN && s_search_string[0])
1971 {
1972 runSearch();
1973 return 0;
1974 }
1975 // fall through
1976 case 'F'-'A'+1:
1977 if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN)
1978 {
1979 draw_message("");
1980 attrset(COLOR_MESSAGE);
1981 bkgdset(COLOR_MESSAGE);
1982 mvaddstr(LINES-1,0,"Find string (ESC to cancel): ");
1983 if (m_selecting && m_select_y1==m_select_y2)
1984 {
1985 WDL_FastString* s=m_text.Get(m_select_y1);
1986 if (s)
1987 {
1988 const char* p=s->Get();
1989 int xlo=wdl_min(m_select_x1, m_select_x2);
1990 int xhi=wdl_max(m_select_x1, m_select_x2);
1991 xlo = WDL_utf8_charpos_to_bytepos(p,xlo);
1992 xhi = WDL_utf8_charpos_to_bytepos(p,xhi);
1993 if (xhi > xlo && xhi-xlo < sizeof(s_search_string))
1994 {
1995 lstrcpyn(s_search_string, p+xlo, xhi-xlo+1);
1996 }
1997 }
1998 }
1999 addstr(s_search_string);
2000 clrtoeol();
2001 attrset(0);
2002 bkgdset(0);
2003 m_ui_state=UI_STATE_SEARCH; // find, initial
2004 }
2005 break;
2006 case KEY_DOWN:
2007 {
2008 if (CTRL_KEY_DOWN)
2009 {
2010 int paney[2], paneh[2];
2011 GetPaneDims(paney, paneh);
2012 int maxscroll=m_text.GetSize()-paneh[m_curpane]+4;
2013 if (m_paneoffs_y[m_curpane] < maxscroll-1)
2014 {
2015 m_paneoffs_y[m_curpane]++;
2016 if (m_curs_y < m_paneoffs_y[m_curpane]) m_curs_y=m_paneoffs_y[m_curpane];
2017 draw();
2018 }
2019 }
2020 else
2021 {
2022 m_curs_y++;
2023 if (m_curs_y>=m_text.GetSize()) m_curs_y=m_text.GetSize()-1;
2024 if (m_curs_y < 0) m_curs_y=0;
2025 }
2026 if (m_selecting) { setCursor(1); m_select_x2=m_curs_x; m_select_y2=m_curs_y; draw(); }
2027 setCursor(1);
2028 }
2029 break;
2030 case KEY_UP:
2031 {
2032 if (CTRL_KEY_DOWN)
2033 {
2034 if (m_paneoffs_y[m_curpane] > 0)
2035 {
2036 int paney[2], paneh[2];
2037 GetPaneDims(paney, paneh);
2038 m_paneoffs_y[m_curpane]--;
2039 if (m_curs_y > m_paneoffs_y[m_curpane]+paneh[m_curpane]-1) m_curs_y = m_paneoffs_y[m_curpane]+paneh[m_curpane]-1;
2040 if (m_curs_y < 0) m_curs_y=0;
2041 draw();
2042 }
2043 }
2044 else
2045 {
2046 if(m_curs_y>0) m_curs_y--;
2047 }
2048 if (m_selecting) { setCursor(1); m_select_x2=m_curs_x; m_select_y2=m_curs_y; draw(); }
2049 setCursor(1);
2050 }
2051 break;
2052 case KEY_PPAGE:
2053 {
2054 if (m_curs_y > m_paneoffs_y[m_curpane])
2055 {
2056 m_curs_y=m_paneoffs_y[m_curpane];
2057 if (m_curs_y < 0) m_curs_y=0;
2058 }
2059 else
2060 {
2061 int paney[2], paneh[2];
2062 GetPaneDims(paney, paneh);
2063 m_curs_y -= paneh[m_curpane];
2064 if (m_curs_y < 0) m_curs_y=0;
2065 m_paneoffs_y[m_curpane]=m_curs_y;
2066 }
2067 if (m_selecting) { setCursor(1); m_select_x2=m_curs_x; m_select_y2=m_curs_y; }
2068 draw();
2069 setCursor(1);
2070 }
2071 break;
2072 case KEY_NPAGE:
2073 {
2074 int paney[2], paneh[2];
2075 GetPaneDims(paney, paneh);
2076 if (m_curs_y >= m_paneoffs_y[m_curpane]+paneh[m_curpane]-1) m_paneoffs_y[m_curpane]=m_curs_y-1;
2077 m_curs_y = m_paneoffs_y[m_curpane]+paneh[m_curpane]-1;
2078 if (m_curs_y >= m_text.GetSize()) m_curs_y=m_text.GetSize()-1;
2079 if (m_curs_y < 0) m_curs_y=0;
2080 if (m_selecting) { setCursor(1); m_select_x2=m_curs_x; m_select_y2=m_curs_y; }
2081 draw();
2082 setCursor(1);
2083 }
2084 break;
2085 case KEY_RIGHT:
2086 {
2087 if (1) // wrap across lines
2088 {
2089 WDL_FastString *s = m_text.Get(m_curs_y);
2090 if (s && m_curs_x >= WDL_utf8_get_charlen(s->Get()) && m_curs_y < m_text.GetSize()) { m_curs_y++; m_curs_x = -1; }
2091 }
2092
2093 if(m_curs_x<0)
2094 {
2095 m_curs_x=0;
2096 }
2097 else
2098 {
2099 if (CTRL_KEY_DOWN)
2100 {
2101 WDL_FastString *s = m_text.Get(m_curs_y);
2102 if (!s) break;
2103 int bytepos = WDL_utf8_charpos_to_bytepos(s->Get(),m_curs_x);
2104
2105 if (bytepos >= s->GetLength()) break;
2106 int lastType = categorizeCharForWordNess(s->Get()[bytepos++]);
2107 while (bytepos < s->GetLength())
2108 {
2109 int thisType = categorizeCharForWordNess(s->Get()[bytepos]);
2110 if (thisType != lastType && thisType != 0) break;
2111 lastType=thisType;
2112 bytepos++;
2113 }
2114 m_curs_x = WDL_utf8_bytepos_to_charpos(s->Get(),bytepos);
2115 }
2116 else
2117 {
2118 m_curs_x++;
2119 }
2120 }
2121 if (m_selecting) { setCursor(); m_select_x2=m_curs_x; m_select_y2=m_curs_y; draw(); }
2122 setCursor();
2123 }
2124 break;
2125 case KEY_LEFT:
2126 {
2127 bool doMove=true;
2128 if (1) // wrap across lines
2129 {
2130 WDL_FastString *s = m_text.Get(m_curs_y);
2131 if (s && m_curs_y>0 && m_curs_x == 0)
2132 {
2133 s = m_text.Get(--m_curs_y);
2134 if (s)
2135 {
2136 m_curs_x = WDL_utf8_get_charlen(s->Get());
2137 doMove=false;
2138 }
2139 }
2140 }
2141
2142 if(m_curs_x>0 && doMove)
2143 {
2144 if (CTRL_KEY_DOWN)
2145 {
2146 WDL_FastString *s = m_text.Get(m_curs_y);
2147 if (!s) break;
2148 int bytepos = WDL_utf8_charpos_to_bytepos(s->Get(),m_curs_x);
2149 if (bytepos > s->GetLength()) bytepos = s->GetLength();
2150 bytepos--;
2151
2152 int lastType = categorizeCharForWordNess(s->Get()[bytepos--]);
2153 while (bytepos >= 0)
2154 {
2155 int thisType = categorizeCharForWordNess(s->Get()[bytepos]);
2156 if (thisType != lastType && lastType != 0) break;
2157 lastType=thisType;
2158 bytepos--;
2159 }
2160 m_curs_x = WDL_utf8_bytepos_to_charpos(s->Get(),bytepos+1);
2161 }
2162 else
2163 {
2164 m_curs_x--;
2165 }
2166 }
2167 if (m_selecting) { setCursor(); m_select_x2=m_curs_x; m_select_y2=m_curs_y; draw(); }
2168 setCursor();
2169 }
2170 break;
2171 case KEY_HOME:
2172 {
2173 m_curs_x=0;
2174 if (CTRL_KEY_DOWN) m_curs_y=0;
2175 if (m_selecting) { setCursor(); m_select_x2=m_curs_x; m_select_y2=m_curs_y; draw(); }
2176 setCursor();
2177 }
2178 break;
2179 case KEY_END:
2180 {
2181 if (m_text.Get(m_curs_y)) m_curs_x=WDL_utf8_get_charlen(m_text.Get(m_curs_y)->Get());
2182 if (CTRL_KEY_DOWN) m_curs_y=m_text.GetSize();
2183 if (m_selecting) { setCursor(); m_select_x2=m_curs_x; m_select_y2=m_curs_y; draw(); }
2184 setCursor();
2185 }
2186 break;
2187 case KEY_BACKSPACE: // backspace, baby
2188 if (m_selecting)
2189 {
2190 preSaveUndoState();
2191 removeSelect();
2192 draw();
2193 saveUndoState();
2194 setCursor();
2195 }
2196 else if (m_curs_x > 0)
2197 {
2198 WDL_FastString *tl=m_text.Get(m_curs_y);
2199 if (tl)
2200 {
2201 preSaveUndoState();
2202
2203 int del_sz=1;
2204 if (m_indent_size > 0 && !(m_curs_x % m_indent_size))
2205 {
2206 const char *p = tl->Get();
2207 int i=0;
2208 while (i<m_curs_x && p[i]== ' ') i++;
2209 if (i == m_curs_x && m_curs_x>=m_indent_size)
2210 {
2211 del_sz=m_indent_size;
2212 }
2213 }
2214
2215 const int xbyte = WDL_utf8_charpos_to_bytepos(tl->Get(),m_curs_x - del_sz);
2216 const int xbytesz=WDL_utf8_charpos_to_bytepos(tl->Get()+xbyte,del_sz);
2217
2218 bool hadCom = LineCanAffectOtherLines(tl->Get(), xbyte,xbytesz);
2219 tl->DeleteSub(xbyte,xbytesz);
2220 m_curs_x-=del_sz;
2221
2222 if (!hadCom) hadCom = LineCanAffectOtherLines(tl->Get(),xbyte,0);
2223 draw(hadCom?-1:m_curs_y);
2224 saveUndoState();
2225 setCursor();
2226 }
2227 }
2228 else // append current line to previous line
2229 {
2230 WDL_FastString *fl=m_text.Get(m_curs_y-1), *tl=m_text.Get(m_curs_y);
2231 if (!tl)
2232 {
2233 m_curs_y--;
2234 if (fl) m_curs_x=WDL_utf8_get_charlen(fl->Get());
2235 draw();
2236 saveUndoState();
2237 setCursor();
2238 }
2239 else if (fl)
2240 {
2241 preSaveUndoState();
2242 m_curs_x=WDL_utf8_get_charlen(fl->Get());
2243 fl->Append(tl->Get());
2244
2245 m_text.Delete(m_curs_y--,true);
2246 draw();
2247 saveUndoState();
2248 setCursor();
2249 }
2250 }
2251 break;
2252 case 'L'-'A'+1:
2253 if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN)
2254 {
2255 draw();
2256 setCursor();
2257 }
2258 break;
2259 case 13: //KEY_ENTER:
2260 //insert newline
2261 preSaveUndoState();
2262
2263 if (m_selecting) { removeSelect(); draw(); setCursor(); }
2264 if (m_curs_y >= m_text.GetSize())
2265 {
2266 m_curs_y=m_text.GetSize();
2267 m_text.Add(new WDL_FastString);
2268 }
2269 if (s_overwrite)
2270 {
2271 WDL_FastString *s = m_text.Get(m_curs_y);
2272 int plen=0;
2273 const char *pb=NULL;
2274 if (s)
2275 {
2276 pb = s->Get();
2277 while (plen < m_curs_x && (pb[plen]== ' ' || pb[plen] == '\t')) plen++;
2278 }
2279 if (++m_curs_y >= m_text.GetSize())
2280 {
2281 m_curs_y = m_text.GetSize();
2282 WDL_FastString *ns=new WDL_FastString;
2283 if (plen>0) ns->Set(pb,plen);
2284 m_text.Insert(m_curs_y,ns);
2285 }
2286 s = m_text.Get(m_curs_y);
2287 if (s && plen > s->GetLength()) plen=s->GetLength();
2288 m_curs_x=s ? WDL_utf8_bytepos_to_charpos(s->Get(),plen) : plen;
2289 }
2290 else
2291 {
2292 WDL_FastString *s = m_text.Get(m_curs_y);
2293 if (s)
2294 {
2295 int bytepos = WDL_utf8_charpos_to_bytepos(s->Get(),m_curs_x);
2296 if (bytepos > s->GetLength()) bytepos = s->GetLength();
2297 WDL_FastString *nl = new WDL_FastString();
2298 int plen=0;
2299 const char *pb = s->Get();
2300 while (plen < bytepos && (pb[plen]== ' ' || pb[plen] == '\t')) plen++;
2301
2302 if (plen>0) nl->Set(pb,plen);
2303
2304 nl->Append(pb+bytepos);
2305 m_text.Insert(++m_curs_y,nl);
2306 s->SetLen(bytepos);
2307 m_curs_x=WDL_utf8_bytepos_to_charpos(nl->Get(),plen);
2308 }
2309 }
2310 m_offs_x=0;
2311
2312 draw();
2313 saveUndoState();
2314 setCursor();
2315 break;
2316 case '\t':
2317 if (m_selecting)
2318 {
2319 preSaveUndoState();
2320
2321 bool isRev = !!(GetAsyncKeyState(VK_SHIFT)&0x8000);
2322 indentSelect(isRev?-m_indent_size:m_indent_size);
2323 // indent selection:
2324 draw();
2325 setCursor();
2326 saveUndoState();
2327 break;
2328 }
2329 default:
2330 //insert char
2331 if(VALIDATE_TEXT_CHAR(c))
2332 {
2333 preSaveUndoState();
2334
2335 if (m_selecting) { removeSelect(); draw(); setCursor(); }
2336 if (!m_text.Get(m_curs_y)) m_text.Insert(m_curs_y,new WDL_FastString);
2337
2338 WDL_FastString *ss;
2339 if ((ss=m_text.Get(m_curs_y)))
2340 {
2341 char str[64];
2342 int slen=1,slen_bytes=1;
2343 if (c == '\t')
2344 {
2345 slen = wdl_min(m_indent_size,64);
2346 if (slen<1) slen=1;
2347
2348 const int partial = m_curs_x % slen;
2349 if (partial) slen -= partial;
2350
2351 int x;
2352 for(x=0;x<slen;x++) str[x]=' ';
2353 slen_bytes=slen;
2354 }
2355 #ifdef __APPLE__
2356 else if (c == 'n' && !SHIFT_KEY_DOWN && ALT_KEY_DOWN)
2357 {
2358 str[0]='~';
2359 }
2360 #endif
2361 else
2362 {
2363 slen_bytes = WDL_MakeUTFChar(str,c,32);
2364 str[slen_bytes]=0;
2365 }
2366
2367
2368 const int xbyte = WDL_utf8_charpos_to_bytepos(ss->Get(),m_curs_x);
2369
2370 bool hadCom = LineCanAffectOtherLines(ss->Get(),xbyte,0);
2371 if (s_overwrite)
2372 {
2373 const int xbytesz_del=WDL_utf8_charpos_to_bytepos(ss->Get()+xbyte,slen);
2374 if (!hadCom) hadCom = LineCanAffectOtherLines(ss->Get(),xbyte,xbytesz_del);
2375 ss->DeleteSub(xbyte,xbytesz_del);
2376 }
2377
2378 ss->Insert(str,xbyte,slen_bytes);
2379 if (!hadCom) hadCom = LineCanAffectOtherLines(ss->Get(),xbyte,slen_bytes);
2380
2381 m_curs_x += slen;
2382
2383 draw(hadCom ? -1 : m_curs_y);
2384 }
2385 saveUndoState();
2386 setCursor();
2387 }
2388 break;
2389 }
2390 return 0;
2391 }
2392
2393 void WDL_CursesEditor::preSaveUndoState()
2394 {
2395 editUndoRec *rec= m_undoStack.Get(m_undoStack_pos);
2396 if (rec)
2397 {
2398 rec->m_offs_x[1]=m_offs_x;
2399 rec->m_curs_x[1]=m_curs_x;
2400 rec->m_curs_y[1]=m_curs_y;
2401 rec->m_curpane[1]=m_curpane;
2402 rec->m_pane_div[1]=m_pane_div;
2403 rec->m_paneoffs_y[1][0]=m_paneoffs_y[0];
2404 rec->m_paneoffs_y[1][1]=m_paneoffs_y[1];
2405 }
2406 }
2407 void WDL_CursesEditor::saveUndoState()
2408 {
2409 editUndoRec *rec=new editUndoRec;
2410 rec->m_offs_x[1]=rec->m_offs_x[0]=m_offs_x;
2411 rec->m_curs_x[1]=rec->m_curs_x[0]=m_curs_x;
2412 rec->m_curs_y[1]=rec->m_curs_y[0]=m_curs_y;
2413 rec->m_curpane[1]=rec->m_curpane[0]=m_curpane;
2414 rec->m_pane_div[1]=rec->m_pane_div[0]=m_pane_div;
2415 rec->m_paneoffs_y[1][0]=rec->m_paneoffs_y[0][0]=m_paneoffs_y[0];
2416 rec->m_paneoffs_y[1][1]=rec->m_paneoffs_y[0][1]=m_paneoffs_y[1];
2417
2418 editUndoRec *lrec[5];
2419 lrec[0] = m_undoStack.Get(m_undoStack_pos);
2420 lrec[1] = m_undoStack.Get(m_undoStack_pos+1);
2421 lrec[2] = m_undoStack.Get(m_undoStack_pos-1);
2422 lrec[3] = m_undoStack.Get(m_undoStack_pos-2);
2423 lrec[4] = m_undoStack.Get(m_undoStack_pos-3);
2424
2425 int x;
2426 for (x = 0; x < m_text.GetSize(); x ++)
2427 {
2428 refcntString *ns = NULL;
2429
2430 const WDL_FastString *s=m_text.Get(x);
2431 const int s_len=s?s->GetLength():0;
2432
2433 if (s_len>0)
2434 {
2435 const char *cs=s?s->Get():"";
2436 int w;
2437 for(w=0;w<5 && !ns;w++)
2438 {
2439 if (lrec[w])
2440 {
2441 int y;
2442 for (y=0; y<15; y ++)
2443 {
2444 refcntString *a = lrec[w]->m_htext.Get(x + ((y&1) ? -(y+1)/2 : y/2));
2445 if (a && a->getStrLen() == s_len && !strcmp(a->getStr(),cs))
2446 {
2447 ns = a;
2448 break;
2449 }
2450 }
2451 }
2452 }
2453
2454 if (!ns) ns = new refcntString(cs,s_len);
2455
2456 ns->AddRef();
2457 }
2458 else
2459 {
2460 // ns is NULL, blank line
2461 }
2462
2463 rec->m_htext.Add(ns);
2464 }
2465
2466 for (x = m_undoStack.GetSize()-1; x > m_undoStack_pos; x --)
2467 {
2468 m_undoStack.Delete(x,true);
2469 }
2470 if (m_clean_undopos > m_undoStack_pos)
2471 m_clean_undopos=-1;
2472
2473 if (m_undoStack.GetSize() > m_max_undo_states)
2474 {
2475 for (x = 1; x < m_undoStack.GetSize()/2; x += 2)
2476 {
2477 if (x != m_clean_undopos)// don't delete our preferred special (last saved) one
2478 {
2479 m_undoStack.Delete(x,true);
2480 if (m_clean_undopos > x) m_clean_undopos--;
2481 x--;
2482 }
2483 }
2484
2485 m_undoStack_pos = m_undoStack.GetSize()-1;
2486 }
2487 m_undoStack_pos++;
2488 m_undoStack.Add(rec);
2489 }
2490
2491 void WDL_CursesEditor::loadUndoState(editUndoRec *rec, int idx)
2492 {
2493 int x;
2494 m_text.Empty(true);
2495 for (x = 0; x < rec->m_htext.GetSize(); x ++)
2496 {
2497 refcntString *s=rec->m_htext.Get(x);
2498 m_text.Add(new WDL_FastString(s?s->getStr():""));
2499 }
2500
2501 m_offs_x=rec->m_offs_x[idx];
2502 m_curs_x=rec->m_curs_x[idx];
2503 m_curs_y=rec->m_curs_y[idx];
2504
2505 m_curpane=rec->m_curpane[idx];
2506 m_pane_div=rec->m_pane_div[idx];
2507 m_paneoffs_y[0]=rec->m_paneoffs_y[idx][0];
2508 m_paneoffs_y[1]=rec->m_paneoffs_y[idx][1];
2509 m_selecting=false;
2510 }
2511
2512
2513 void WDL_CursesEditor::RunEditor()
2514 {
2515 int x;
2516 for(x=0;x<16;x++)
2517 {
2518 if (!CURSES_INSTANCE) break;
2519
2520 int thischar = getch();
2521 if (thischar==ERR) break;
2522
2523 if (onChar(thischar)) break;
2524 }
2525 }
2526
2527 void WDL_CursesEditor::draw_top_line()
2528 {
2529 int ypos=0;
2530 if (m_top_margin > 1)
2531 {
2532 int xpos=0;
2533 int x;
2534 move(ypos++,0);
2535 const int cnt= GetTabCount();
2536 int tsz=16;
2537 // this is duplicated in onMouseMessage
2538 if (cnt>0) tsz=COLS/cnt;
2539 if (tsz>128)tsz=128;
2540 if (tsz<12) tsz=12;
2541
2542 for (x= 0; x < cnt && xpos < COLS; x ++)
2543 {
2544 WDL_CursesEditor *ed = GetTab(x);
2545 if (ed)
2546 {
2547 char buf[128 + 8];
2548 memset(buf,' ',tsz);
2549 const char *p = WDL_get_filepart(ed->GetFileName());
2550 const int lp=strlen(p);
2551 int skip=0;
2552 if (x<9)
2553 {
2554 if (tsz>16)
2555 {
2556 const char *s = "<" CONTROL_KEY_NAME "+";
2557 memcpy(buf,s,skip = (int)strlen(s));
2558 }
2559 buf[skip++]='F';
2560 buf[skip++] = '1'+x;
2561 buf[skip++] = '>';
2562 skip++;
2563 }
2564 memcpy(buf+skip,p,wdl_min(tsz-1-skip,lp));
2565 buf[tsz]=0;
2566 int l = tsz;
2567 if (l > COLS-xpos) l = COLS-xpos;
2568 if (ed == this)
2569 {
2570 attrset(SYNTAX_HIGHLIGHT2|A_BOLD);
2571 }
2572 else
2573 {
2574 attrset(A_NORMAL);
2575 }
2576 addnstr(buf,l);
2577 xpos += l;
2578 }
2579 }
2580 if (xpos < COLS) clrtoeol();
2581 }
2582 attrset(COLOR_TOPLINE|A_BOLD);
2583 bkgdset(COLOR_TOPLINE);
2584 const char *p=GetFileName();
2585 move(ypos,0);
2586 if (COLS>4)
2587 {
2588 const int pl = (int) strlen(p);
2589 if (pl > COLS-1 && COLS > 4)
2590 {
2591 addstr("...");
2592 p+=pl - (COLS-1) + 4;
2593 }
2594 addstr(p);
2595 }
2596 clrtoeol();
2597 }
2598
2599 void WDL_CursesEditor::OpenFileInTab(const char *fnp)
2600 {
2601 if (!fnp[0]) return;
2602
2603 FILE *fp = fopen(fnp,"rb");
2604 if (!fp)
2605 {
2606 WDL_FastString s(fnp);
2607 m_newfn.Set(fnp);
2608
2609 if (COLS > 25)
2610 {
2611 int allowed = COLS-25;
2612 if (s.GetLength()>allowed)
2613 {
2614 s.DeleteSub(0,s.GetLength() - allowed + 3);
2615 s.Insert("...",0);
2616 }
2617 s.Insert("Create new file '",0);
2618 s.Append("' (Y/n)? ");
2619 }
2620 else
2621 s.Set("Create new file (Y/n)? ");
2622
2623 m_ui_state=UI_STATE_SAVE_AS_NEW;
2624 attrset(COLOR_MESSAGE);
2625 bkgdset(COLOR_MESSAGE);
2626 mvaddstr(LINES-1,0,s.Get());
2627 clrtoeol();
2628 attrset(0);
2629 bkgdset(0);
2630 }
2631 else
2632 {
2633 fclose(fp);
2634 int x;
2635 for (x=0;x<GetTabCount();x++)
2636 {
2637 WDL_CursesEditor *e = GetTab(x);
2638 if (e && !stricmp(e->GetFileName(),fnp))
2639 {
2640 SwitchTab(x,false);
2641 return;
2642 }
2643 }
2644 AddTab(fnp);
2645 }
2646 }
2647
Enhanced version of Cockos' IPlug - A simple-to-use C++ framework for developing cross platform audio plugins and targeting multiple plugin APIs with the same code. VST / VST3 / Audiounit / RTAS / AAX (Native) formats supported. (git mirror)