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