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