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