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