make console wrapped text drawing into its own function in preparation to move report...
[blender-staging.git] / source / blender / editors / space_console / console_ops.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * Contributor(s): Campbell Barton
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 #include <stdlib.h>
26 #include <string.h>
27 #include <ctype.h> /* ispunct */
28 #include <sys/stat.h>
29
30 #include "MEM_guardedalloc.h"
31
32 #include "DNA_userdef_types.h"
33
34 #include "BLI_blenlib.h"
35 #include "BLI_dynstr.h"
36
37 #include "BKE_context.h"
38 #include "BKE_text.h" /* only for character utility funcs */
39
40 #include "WM_api.h"
41 #include "WM_types.h"
42
43 #include "ED_screen.h"
44
45 #include "RNA_access.h"
46 #include "RNA_define.h"
47
48 #include "console_intern.h"
49
50 static void console_select_offset(SpaceConsole *sc, const int offset)
51 {
52         sc->sel_start += offset;
53         sc->sel_end += offset;
54 }
55
56 void console_history_free(SpaceConsole *sc, ConsoleLine *cl)
57 {
58         BLI_remlink(&sc->history, cl);
59         MEM_freeN(cl->line);
60         MEM_freeN(cl);
61 }
62 void console_scrollback_free(SpaceConsole *sc, ConsoleLine *cl)
63 {
64         BLI_remlink(&sc->scrollback, cl);
65         MEM_freeN(cl->line);
66         MEM_freeN(cl);
67 }
68
69 void console_scrollback_limit(SpaceConsole *sc)
70 {
71         int tot;
72         
73         if (U.scrollback < 32) U.scrollback= 128; // XXX - save in user defaults
74         
75         for(tot= BLI_countlist(&sc->scrollback); tot > U.scrollback; tot--)
76                 console_scrollback_free(sc, sc->scrollback.first);
77 }
78
79 static ConsoleLine * console_history_find(SpaceConsole *sc, const char *str, ConsoleLine *cl_ignore)
80 {
81         ConsoleLine *cl;
82
83         for(cl= sc->history.last; cl; cl= cl->prev) {
84                 if (cl==cl_ignore)
85                         continue;
86
87                 if(strcmp(str, cl->line)==0)
88                         return cl;
89         }
90
91         return NULL;
92 }
93
94 /* return 0 if no change made, clamps the range */
95 static int console_line_cursor_set(ConsoleLine *cl, int cursor)
96 {
97         int cursor_new;
98         
99         if(cursor < 0)                          cursor_new= 0;
100         else if(cursor > cl->len)       cursor_new= cl->len;
101         else                                            cursor_new= cursor;
102         
103         if(cursor_new == cl->cursor)
104                 return 0;
105         
106         cl->cursor= cursor_new;
107         return 1;
108 }
109
110 static char cursor_char(ConsoleLine *cl)
111 {
112         /* assume cursor is clamped */
113         return cl->line[cl->cursor];
114 }
115
116 static char cursor_char_prev(ConsoleLine *cl)
117 {
118         /* assume cursor is clamped */
119         if(cl->cursor <= 0)
120                 return '\0';
121
122         return cl->line[cl->cursor-1];
123 }
124
125 #if 0 // XXX unused 
126 static char cursor_char_next(ConsoleLine *cl)
127 {
128         /* assume cursor is clamped */
129         if(cl->cursor + 1 >= cl->len)
130                 return '\0';
131
132         return cl->line[cl->cursor+1];
133 }
134
135 static void console_lb_debug__internal(ListBase *lb)
136 {
137         ConsoleLine *cl;
138
139         printf("%d: ", BLI_countlist(lb));
140         for(cl= lb->first; cl; cl= cl->next)
141                 printf("<%s> ", cl->line);
142         printf("\n");
143
144 }
145
146 static void console_history_debug(const bContext *C)
147 {
148         SpaceConsole *sc= CTX_wm_space_console(C);
149
150         
151         console_lb_debug__internal(&sc->history);
152 }
153 #endif
154
155 static ConsoleLine *console_lb_add__internal(ListBase *lb, ConsoleLine *from)
156 {
157         ConsoleLine *ci= MEM_callocN(sizeof(ConsoleLine), "ConsoleLine Add");
158         
159         if(from) {
160                 ci->line= BLI_strdup(from->line);
161                 ci->len= strlen(ci->line);
162                 ci->len_alloc= ci->len;
163                 
164                 ci->cursor= from->cursor;
165                 ci->type= from->type;
166         } else {
167                 ci->line= MEM_callocN(64, "console-in-line");
168                 ci->len_alloc= 64;
169                 ci->len= 0;
170         }
171         
172         BLI_addtail(lb, ci);
173         return ci;
174 }
175
176 static ConsoleLine *console_history_add(const bContext *C, ConsoleLine *from)
177 {
178         SpaceConsole *sc= CTX_wm_space_console(C);
179         
180         return console_lb_add__internal(&sc->history, from);
181 }
182
183 #if 0 /* may use later ? */
184 static ConsoleLine *console_scrollback_add(const bContext *C, ConsoleLine *from)
185 {
186         SpaceConsole *sc= CTX_wm_space_console(C);
187         
188         return console_lb_add__internal(&sc->scrollback, from);
189 }
190 #endif
191
192 static ConsoleLine *console_lb_add_str__internal(ListBase *lb, char *str, int own)
193 {
194         ConsoleLine *ci= MEM_callocN(sizeof(ConsoleLine), "ConsoleLine Add");
195         if(own)         ci->line= str;
196         else            ci->line= BLI_strdup(str);
197         
198         ci->len = ci->len_alloc = strlen(str);
199         
200         BLI_addtail(lb, ci);
201         return ci;
202 }
203 ConsoleLine *console_history_add_str(SpaceConsole *sc, char *str, int own)
204 {
205         return console_lb_add_str__internal(&sc->history, str, own);
206 }
207 ConsoleLine *console_scrollback_add_str(SpaceConsole *sc, char *str, int own)
208 {
209         ConsoleLine *ci= console_lb_add_str__internal(&sc->scrollback, str, own);
210         console_select_offset(sc, ci->len + 1);
211         return ci;
212 }
213
214 ConsoleLine *console_history_verify(const bContext *C)
215 {
216         SpaceConsole *sc= CTX_wm_space_console(C);
217         ConsoleLine *ci= sc->history.last;
218         if(ci==NULL)
219                 ci= console_history_add(C, NULL);
220         
221         return ci;
222 }
223
224
225 static void console_line_verify_length(ConsoleLine *ci, int len)
226 {
227         /* resize the buffer if needed */
228         if(len >= ci->len_alloc) {
229                 int new_len= len * 2; /* new length */
230                 char *new_line= MEM_callocN(new_len, "console line");
231                 memcpy(new_line, ci->line, ci->len);
232                 MEM_freeN(ci->line);
233                 
234                 ci->line= new_line;
235                 ci->len_alloc= new_len;
236         }
237 }
238
239 static int console_line_insert(ConsoleLine *ci, char *str)
240 {
241         int len = strlen(str);
242         
243         if(len>0 && str[len-1]=='\n') {/* stop new lines being pasted at the end of lines */
244                 str[len-1]= '\0';
245                 len--;
246         }
247
248         if(len==0)
249                 return 0;
250         
251         console_line_verify_length(ci, len + ci->len);
252         
253         memmove(ci->line+ci->cursor+len, ci->line+ci->cursor, (ci->len - ci->cursor)+1);
254         memcpy(ci->line+ci->cursor, str, len);
255         
256         ci->len += len;
257         ci->cursor += len;
258         
259         return len;
260 }
261
262 static int console_edit_poll(bContext *C)
263 {
264         SpaceConsole *sc= CTX_wm_space_console(C);
265
266         if(!sc || sc->type != CONSOLE_TYPE_PYTHON)
267                 return 0;
268
269         return 1;
270 }
271 #if 0
272 static int console_poll(bContext *C)
273 {
274         return (CTX_wm_space_console(C) != NULL);
275 }
276 #endif
277
278 /* static funcs for text editing */
279
280 /* similar to the text editor, with some not used. keep compatible */
281 static EnumPropertyItem move_type_items[]= {
282         {LINE_BEGIN, "LINE_BEGIN", 0, "Line Begin", ""},
283         {LINE_END, "LINE_END", 0, "Line End", ""},
284         {PREV_CHAR, "PREVIOUS_CHARACTER", 0, "Previous Character", ""},
285         {NEXT_CHAR, "NEXT_CHARACTER", 0, "Next Character", ""},
286         {PREV_WORD, "PREVIOUS_WORD", 0, "Previous Word", ""},
287         {NEXT_WORD, "NEXT_WORD", 0, "Next Word", ""},
288         {0, NULL, 0, NULL, NULL}};
289
290 static int move_exec(bContext *C, wmOperator *op)
291 {
292         ConsoleLine *ci= console_history_verify(C);
293         
294         int type= RNA_enum_get(op->ptr, "type");
295         int done= 0;
296         
297         switch(type) {
298         case LINE_BEGIN:
299                 done= console_line_cursor_set(ci, 0);
300                 break;
301         case LINE_END:
302                 done= console_line_cursor_set(ci, INT_MAX);
303                 break;
304         case PREV_CHAR:
305                 done= console_line_cursor_set(ci, ci->cursor-1);
306                 break;
307         case NEXT_CHAR:
308                 done= console_line_cursor_set(ci, ci->cursor+1);
309                 break;
310
311         /* - if the character is a delimiter then skip delimiters (including white space)
312          * - when jump over the word */
313         case PREV_WORD:
314                 while(text_check_delim(cursor_char_prev(ci)))
315                         if(console_line_cursor_set(ci, ci->cursor-1)==FALSE)
316                                 break;
317
318                 while(text_check_delim(cursor_char_prev(ci))==FALSE)
319                         if(console_line_cursor_set(ci, ci->cursor-1)==FALSE)
320                                 break;
321
322                 /* This isnt used for NEXT_WORD because when going back
323                  * its more useful to have the cursor directly after a word then whitespace */
324                 while(text_check_whitespace(cursor_char_prev(ci))==TRUE)
325                         if(console_line_cursor_set(ci, ci->cursor-1)==FALSE)
326                                 break;
327
328                 done= 1; /* assume changed */
329                 break;
330         case NEXT_WORD:
331                 while(text_check_delim(cursor_char(ci))==TRUE)
332                         if (console_line_cursor_set(ci, ci->cursor+1)==FALSE)
333                                 break;
334
335                 while(text_check_delim(cursor_char(ci))==FALSE)
336                         if (console_line_cursor_set(ci, ci->cursor+1)==FALSE)
337                                 break;
338
339                 done= 1; /* assume changed */
340                 break;
341         }
342         
343         if(done) {
344                 ED_area_tag_redraw(CTX_wm_area(C));
345         }
346         
347         return OPERATOR_FINISHED;
348 }
349
350 void CONSOLE_OT_move(wmOperatorType *ot)
351 {
352         /* identifiers */
353         ot->name= "Move Cursor";
354         ot->description= "Move cursor position";
355         ot->idname= "CONSOLE_OT_move";
356         
357         /* api callbacks */
358         ot->exec= move_exec;
359         ot->poll= console_edit_poll;
360
361         /* properties */
362         RNA_def_enum(ot->srna, "type", move_type_items, LINE_BEGIN, "Type", "Where to move cursor to.");
363 }
364
365 #define TAB_LENGTH 4
366 static int insert_exec(bContext *C, wmOperator *op)
367 {
368         ConsoleLine *ci= console_history_verify(C);
369         char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0);
370         int len;
371
372         // XXX, alligned tab key hack
373         if(str[0]=='\t' && str[1]=='\0') {
374                 int len= TAB_LENGTH - (ci->cursor % TAB_LENGTH);
375                 MEM_freeN(str);
376                 str= MEM_mallocN(len + 1, "insert_exec");
377                 memset(str, ' ', len);
378                 str[len]= '\0';
379         }
380
381         len= console_line_insert(ci, str);
382         
383         MEM_freeN(str);
384         
385         if(len==0) {
386                 return OPERATOR_CANCELLED;
387         }
388         else {
389                 SpaceConsole *sc= CTX_wm_space_console(C);
390                 console_select_offset(sc, len);
391         }
392                 
393         ED_area_tag_redraw(CTX_wm_area(C));
394         
395         return OPERATOR_FINISHED;
396 }
397
398 static int insert_invoke(bContext *C, wmOperator *op, wmEvent *event)
399 {
400         // if(!RNA_property_is_set(op->ptr, "text")) { /* always set from keymap XXX */
401         if(!RNA_string_length(op->ptr, "text")) {
402                 /* if alt/ctrl/super are pressed pass through */
403                 if(event->ctrl || event->oskey) {
404                         return OPERATOR_PASS_THROUGH;
405                 }
406                 else {
407                         char str[2];
408                         str[0]= event->ascii;
409                         str[1]= '\0';
410
411                         RNA_string_set(op->ptr, "text", str);
412                 }
413         }
414         return insert_exec(C, op);
415 }
416
417 void CONSOLE_OT_insert(wmOperatorType *ot)
418 {
419         /* identifiers */
420         ot->name= "Insert";
421         ot->description= "Insert text at cursor position";
422         ot->idname= "CONSOLE_OT_insert";
423         
424         /* api callbacks */
425         ot->exec= insert_exec;
426         ot->invoke= insert_invoke;
427         ot->poll= console_edit_poll;
428
429         /* properties */
430         RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");
431 }
432
433
434 static EnumPropertyItem delete_type_items[]= {
435         {DEL_NEXT_CHAR, "NEXT_CHARACTER", 0, "Next Character", ""},
436         {DEL_PREV_CHAR, "PREVIOUS_CHARACTER", 0, "Previous Character", ""},
437 //      {DEL_NEXT_WORD, "NEXT_WORD", 0, "Next Word", ""},
438 //      {DEL_PREV_WORD, "PREVIOUS_WORD", 0, "Previous Word", ""},
439         {0, NULL, 0, NULL, NULL}};
440
441 static int delete_exec(bContext *C, wmOperator *op)
442 {
443         
444         ConsoleLine *ci= console_history_verify(C);
445         
446         
447         int done = 0;
448
449         int type= RNA_enum_get(op->ptr, "type");
450         
451         if(ci->len==0) {
452                 return OPERATOR_CANCELLED;
453         }
454         
455         switch(type) {
456         case DEL_NEXT_CHAR:
457                 if(ci->cursor < ci->len) {
458                         memmove(ci->line + ci->cursor, ci->line + ci->cursor+1, (ci->len - ci->cursor)+1);
459                         ci->len--;
460                         done= 1;
461                 }
462                 break;
463         case DEL_PREV_CHAR:
464                 if(ci->cursor > 0) {
465                         ci->cursor--; /* same as above */
466                         memmove(ci->line + ci->cursor, ci->line + ci->cursor+1, (ci->len - ci->cursor)+1);
467                         ci->len--;
468                         done= 1;
469                 }
470                 break;
471         }
472         
473         if(!done) {
474                 return OPERATOR_CANCELLED;
475         }
476         else {
477                 SpaceConsole *sc= CTX_wm_space_console(C);
478                 console_select_offset(sc, -1);
479         }
480         
481         ED_area_tag_redraw(CTX_wm_area(C));
482         
483         return OPERATOR_FINISHED;
484 }
485
486
487 void CONSOLE_OT_delete(wmOperatorType *ot)
488 {
489         /* identifiers */
490         ot->name= "Delete";
491         ot->description= "Delete text by cursor position";
492         ot->idname= "CONSOLE_OT_delete";
493         
494         /* api callbacks */
495         ot->exec= delete_exec;
496         ot->poll= console_edit_poll;
497
498         /* properties */
499         RNA_def_enum(ot->srna, "type", delete_type_items, DEL_NEXT_CHAR, "Type", "Which part of the text to delete.");
500 }
501
502
503 /* the python exec operator uses this */
504 static int clear_exec(bContext *C, wmOperator *op)
505 {
506         SpaceConsole *sc= CTX_wm_space_console(C);
507         
508         short scrollback= RNA_boolean_get(op->ptr, "scrollback");
509         short history= RNA_boolean_get(op->ptr, "history");
510         
511         /*ConsoleLine *ci= */ console_history_verify(C);
512         
513         if(scrollback) { /* last item in mistory */
514                 while(sc->scrollback.first)
515                         console_scrollback_free(sc, sc->scrollback.first);
516         }
517         
518         if(history) {
519                 while(sc->history.first)
520                         console_history_free(sc, sc->history.first);
521         }
522         
523         ED_area_tag_redraw(CTX_wm_area(C));
524         
525         return OPERATOR_FINISHED;
526 }
527
528 void CONSOLE_OT_clear(wmOperatorType *ot)
529 {
530         /* identifiers */
531         ot->name= "Clear";
532         ot->description= "Clear text by type";
533         ot->idname= "CONSOLE_OT_clear";
534         
535         /* api callbacks */
536         ot->exec= clear_exec;
537         ot->poll= console_edit_poll;
538         
539         /* properties */
540         RNA_def_boolean(ot->srna, "scrollback", 1, "Scrollback", "Clear the scrollback history");
541         RNA_def_boolean(ot->srna, "history", 0, "History", "Clear the command history");
542 }
543
544
545
546 /* the python exec operator uses this */
547 static int history_cycle_exec(bContext *C, wmOperator *op)
548 {
549         SpaceConsole *sc= CTX_wm_space_console(C);
550         ConsoleLine *ci= console_history_verify(C); /* TODO - stupid, just prevernts crashes when no command line */
551         short reverse= RNA_boolean_get(op->ptr, "reverse"); /* assumes down, reverse is up */
552         int prev_len= ci->len;
553
554         /* keep a copy of the line above so when history is cycled
555          * this is the only function that needs to know about the double-up */
556         if(ci->prev) {
557                 ConsoleLine *ci_prev= (ConsoleLine *)ci->prev;
558
559                 if(strcmp(ci->line, ci_prev->line)==0)
560                         console_history_free(sc, ci_prev);
561         }
562
563         if(reverse) { /* last item in mistory */
564                 ci= sc->history.last;
565                 BLI_remlink(&sc->history, ci);
566                 BLI_addhead(&sc->history, ci);
567         }
568         else {
569                 ci= sc->history.first;
570                 BLI_remlink(&sc->history, ci);
571                 BLI_addtail(&sc->history, ci);
572         }
573
574         {       /* add a duplicate of the new arg and remove all other instances */
575                 ConsoleLine *cl;
576                 while((cl= console_history_find(sc, ci->line, ci)))
577                         console_history_free(sc, cl);
578
579                 console_history_add(C, (ConsoleLine *)sc->history.last);
580         }
581         
582         ci= sc->history.last;
583         console_select_offset(sc, ci->len - prev_len);
584
585         ED_area_tag_redraw(CTX_wm_area(C));
586
587         return OPERATOR_FINISHED;
588 }
589
590 void CONSOLE_OT_history_cycle(wmOperatorType *ot)
591 {
592         /* identifiers */
593         ot->name= "History Cycle";
594         ot->description= "Cycle through history";
595         ot->idname= "CONSOLE_OT_history_cycle";
596         
597         /* api callbacks */
598         ot->exec= history_cycle_exec;
599         ot->poll= console_edit_poll;
600         
601         /* properties */
602         RNA_def_boolean(ot->srna, "reverse", 0, "Reverse", "reverse cycle history");
603 }
604
605
606 /* the python exec operator uses this */
607 static int history_append_exec(bContext *C, wmOperator *op)
608 {
609         SpaceConsole *sc= CTX_wm_space_console(C);
610         ConsoleLine *ci= console_history_verify(C);
611         char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0); /* own this text in the new line, dont free */
612         int cursor= RNA_int_get(op->ptr, "current_character");
613         short rem_dupes= RNA_boolean_get(op->ptr, "remove_duplicates");
614         int prev_len= ci->len;
615
616         if(rem_dupes) {
617                 SpaceConsole *sc= CTX_wm_space_console(C);
618                 ConsoleLine *cl;
619
620                 while((cl= console_history_find(sc, ci->line, ci)))
621                         console_history_free(sc, cl);
622
623                 if(strcmp(str, ci->line)==0) {
624                         MEM_freeN(str);
625                         return OPERATOR_FINISHED;
626                 }
627         }
628
629         ci= console_history_add_str(sc, str, 1); /* own the string */
630         console_select_offset(sc, ci->len - prev_len);
631         console_line_cursor_set(ci, cursor);
632         
633         ED_area_tag_redraw(CTX_wm_area(C));
634         
635         return OPERATOR_FINISHED;
636 }
637
638 void CONSOLE_OT_history_append(wmOperatorType *ot)
639 {
640         /* identifiers */
641         ot->name= "History Append";
642         ot->description= "Append history at cursor position";
643         ot->idname= "CONSOLE_OT_history_append";
644         
645         /* api callbacks */
646         ot->exec= history_append_exec;
647         ot->poll= console_edit_poll;
648         
649         /* properties */
650         RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");      
651         RNA_def_int(ot->srna, "current_character", 0, 0, INT_MAX, "Cursor", "The index of the cursor.", 0, 10000);
652         RNA_def_boolean(ot->srna, "remove_duplicates", 0, "Remove Duplicates", "Remove duplicate items in the history");
653 }
654
655
656 /* the python exec operator uses this */
657 static int scrollback_append_exec(bContext *C, wmOperator *op)
658 {
659         SpaceConsole *sc= CTX_wm_space_console(C);
660         ConsoleLine *ci= console_history_verify(C);
661         
662         char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0); /* own this text in the new line, dont free */
663         int type= RNA_enum_get(op->ptr, "type");
664         
665         ci= console_scrollback_add_str(sc, str, 1); /* own the string */
666         ci->type= type;
667         
668         console_scrollback_limit(sc);
669         
670         ED_area_tag_redraw(CTX_wm_area(C));
671         
672         return OPERATOR_FINISHED;
673 }
674
675 void CONSOLE_OT_scrollback_append(wmOperatorType *ot)
676 {
677         /* defined in DNA_space_types.h */
678         static EnumPropertyItem console_line_type_items[] = {
679                 {CONSOLE_LINE_OUTPUT,   "OUTPUT", 0, "Output", ""},
680                 {CONSOLE_LINE_INPUT,    "INPUT", 0, "Input", ""},
681                 {CONSOLE_LINE_INFO,             "INFO", 0, "Information", ""},
682                 {CONSOLE_LINE_ERROR,    "ERROR", 0, "Error", ""},
683                 {0, NULL, 0, NULL, NULL}};
684
685         /* identifiers */
686         ot->name= "Scrollback Append";
687         ot->description= "Append scrollback text by type";
688         ot->idname= "CONSOLE_OT_scrollback_append";
689         
690         /* api callbacks */
691         ot->exec= scrollback_append_exec;
692         ot->poll= console_edit_poll;
693         
694         /* properties */
695         RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");      
696         RNA_def_enum(ot->srna, "type", console_line_type_items, CONSOLE_LINE_OUTPUT, "Type", "Console output type.");
697 }
698
699
700 static int copy_exec(bContext *C, wmOperator *UNUSED(op))
701 {
702         SpaceConsole *sc= CTX_wm_space_console(C);
703         int buf_len;
704
705         DynStr *buf_dyn= BLI_dynstr_new();
706         char *buf_str;
707         
708         ConsoleLine *cl;
709         int sel[2];
710         int offset= 0;
711
712         ConsoleLine cl_dummy= {0};
713
714 #if 0
715         /* copy whole file */
716         for(cl= sc->scrollback.first; cl; cl= cl->next) {
717                 BLI_dynstr_append(buf_dyn, cl->line);
718                 BLI_dynstr_append(buf_dyn, "\n");
719         }
720 #endif
721
722         if(sc->sel_start == sc->sel_end)
723                 return OPERATOR_CANCELLED;
724
725         console_scrollback_prompt_begin(sc, &cl_dummy);
726
727         for(cl= sc->scrollback.first; cl; cl= cl->next) {
728                 offset += cl->len + 1;
729         }
730
731         if(offset==0) {
732                 console_scrollback_prompt_end(sc, &cl_dummy);
733                 return OPERATOR_CANCELLED;
734         }
735
736         offset -= 1;
737         sel[0]= offset - sc->sel_end;
738         sel[1]= offset - sc->sel_start;
739
740         for(cl= sc->scrollback.first; cl; cl= cl->next) {
741                 if(sel[0] <= cl->len && sel[1] >= 0) {
742                         int sta= MAX2(sel[0], 0);
743                         int end= MIN2(sel[1], cl->len);
744
745                         if(BLI_dynstr_get_len(buf_dyn))
746                                 BLI_dynstr_append(buf_dyn, "\n");
747
748                         BLI_dynstr_nappend(buf_dyn, cl->line + sta, end - sta);
749                 }
750
751                 sel[0] -= cl->len + 1;
752                 sel[1] -= cl->len + 1;
753         }
754
755         buf_str= BLI_dynstr_get_cstring(buf_dyn);
756         buf_len= BLI_dynstr_get_len(buf_dyn);
757         BLI_dynstr_free(buf_dyn);
758         WM_clipboard_text_set(buf_str, 0);
759
760         MEM_freeN(buf_str);
761
762         console_scrollback_prompt_end(sc, &cl_dummy);
763
764         return OPERATOR_FINISHED;
765 }
766
767 void CONSOLE_OT_copy(wmOperatorType *ot)
768 {
769         /* identifiers */
770         ot->name= "Copy to Clipboard";
771         ot->description= "Copy selected text to clipboard";
772         ot->idname= "CONSOLE_OT_copy";
773
774         /* api callbacks */
775         ot->poll= console_edit_poll;
776         ot->exec= copy_exec;
777
778         /* properties */
779 }
780
781 static int paste_exec(bContext *C, wmOperator *UNUSED(op))
782 {
783         SpaceConsole *sc= CTX_wm_space_console(C);
784         ConsoleLine *ci= console_history_verify(C);
785
786         char *buf_str= WM_clipboard_text_get(0);
787         char *buf_step, *buf_next;
788
789         if(buf_str==NULL)
790                 return OPERATOR_CANCELLED;
791
792         buf_next= buf_str;
793         buf_step= buf_str;
794
795         while((buf_next=buf_step) && buf_next[0] != '\0') {
796                 buf_step= strchr(buf_next, '\n');
797                 if(buf_step) {
798                         *buf_step= '\0';
799                         buf_step++;
800                 }
801
802                 if(buf_next != buf_str) {
803                         WM_operator_name_call(C, "CONSOLE_OT_execute", WM_OP_EXEC_DEFAULT, NULL);
804                         ci= console_history_verify(C);
805                 }
806
807                 console_select_offset(sc, console_line_insert(ci, buf_next));
808         }
809
810         MEM_freeN(buf_str);
811
812         ED_area_tag_redraw(CTX_wm_area(C));
813
814         return OPERATOR_FINISHED;
815 }
816
817 void CONSOLE_OT_paste(wmOperatorType *ot)
818 {
819         /* identifiers */
820         ot->name= "Paste from Clipboard";
821         ot->description= "Paste text from clipboard";
822         ot->idname= "CONSOLE_OT_paste";
823
824         /* api callbacks */
825         ot->poll= console_edit_poll;
826         ot->exec= paste_exec;
827
828         /* properties */
829 }
830
831 typedef struct SetConsoleCursor {
832         int sel_old[2];
833         int sel_init;
834 } SetConsoleCursor;
835
836 // TODO, cursor placement without selection
837 static void set_cursor_to_pos(SpaceConsole *sc, ARegion *ar, SetConsoleCursor *scu, int mval[2], int UNUSED(sel))
838 {
839         int pos;
840         pos= console_char_pick(sc, ar, NULL, mval);
841
842         if(scu->sel_init == INT_MAX) {
843                 scu->sel_init= pos;
844                 sc->sel_start = sc->sel_end = pos;
845                 return;
846         }
847
848         if (pos < scu->sel_init) {
849                 sc->sel_start = pos;
850                 sc->sel_end = scu->sel_init;
851         }
852         else if (pos > sc->sel_start) {
853                 sc->sel_start = scu->sel_init;
854                 sc->sel_end = pos;
855         }
856         else {
857                 sc->sel_start = sc->sel_end = pos;
858         }
859 }
860
861 static void console_modal_select_apply(bContext *C, wmOperator *op, wmEvent *event)
862 {
863         SpaceConsole *sc= CTX_wm_space_console(C);
864         ARegion *ar= CTX_wm_region(C);
865         SetConsoleCursor *scu= op->customdata;
866         int mval[2];
867
868         mval[0]= event->mval[0];
869         mval[1]= event->mval[1];
870
871         set_cursor_to_pos(sc, ar, scu, mval, TRUE);
872         ED_area_tag_redraw(CTX_wm_area(C));
873 }
874
875 static void set_cursor_exit(bContext *UNUSED(C), wmOperator *op)
876 {
877 //      SpaceConsole *sc= CTX_wm_space_console(C);
878         SetConsoleCursor *scu= op->customdata;
879
880         /*
881         if(txt_has_sel(text)) {
882                 buffer = txt_sel_to_buf(text);
883                 WM_clipboard_text_set(buffer, 1);
884                 MEM_freeN(buffer);
885         }*/
886
887         MEM_freeN(scu);
888 }
889
890 static int console_modal_select_invoke(bContext *C, wmOperator *op, wmEvent *event)
891 {
892         SpaceConsole *sc= CTX_wm_space_console(C);
893 //      ARegion *ar= CTX_wm_region(C);
894         SetConsoleCursor *scu;
895
896         op->customdata= MEM_callocN(sizeof(SetConsoleCursor), "SetConsoleCursor");
897         scu= op->customdata;
898
899         scu->sel_old[0]= sc->sel_start;
900         scu->sel_old[1]= sc->sel_end;
901
902         scu->sel_init = INT_MAX;
903
904         WM_event_add_modal_handler(C, op);
905
906         console_modal_select_apply(C, op, event);
907
908         return OPERATOR_RUNNING_MODAL;
909 }
910
911 static int console_modal_select(bContext *C, wmOperator *op, wmEvent *event)
912 {
913         switch(event->type) {
914                 case LEFTMOUSE:
915                 case MIDDLEMOUSE:
916                 case RIGHTMOUSE:
917                         set_cursor_exit(C, op);
918                         return OPERATOR_FINISHED;
919                 case MOUSEMOVE:
920                         console_modal_select_apply(C, op, event);
921                         break;
922         }
923
924         return OPERATOR_RUNNING_MODAL;
925 }
926
927 static int console_modal_select_cancel(bContext *C, wmOperator *op)
928 {
929         set_cursor_exit(C, op);
930         return OPERATOR_FINISHED;
931 }
932
933 void CONSOLE_OT_select_set(wmOperatorType *ot)
934 {
935         /* identifiers */
936         ot->name= "Set Selection";
937         ot->idname= "CONSOLE_OT_select_set";
938         ot->description= "Set the console selection";
939
940         /* api callbacks */
941         ot->invoke= console_modal_select_invoke;
942         ot->modal= console_modal_select;
943         ot->cancel= console_modal_select_cancel;
944         ot->poll= console_edit_poll;
945 }