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