- off by 1 error with console command line memory re-allocation.
[blender-staging.git] / source / blender / editors / space_console / console_ops.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): Campbell Barton
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 #include <stdlib.h>
31 #include <string.h>
32 #include <ctype.h> /* ispunct */
33 #include <sys/stat.h>
34
35 #include "MEM_guardedalloc.h"
36
37 #include "DNA_scene_types.h"
38 #include "DNA_screen_types.h"
39 #include "DNA_space_types.h"
40 #include "DNA_userdef_types.h"
41 #include "DNA_windowmanager_types.h"
42
43 #include "BLI_blenlib.h"
44 #include "BLI_dynstr.h"
45 #include "PIL_time.h"
46
47 #include "BKE_utildefines.h"
48 #include "BKE_context.h"
49 #include "BKE_depsgraph.h"
50 #include "BKE_global.h"
51 #include "BKE_library.h"
52 #include "BKE_main.h"
53 #include "BKE_report.h"
54
55 #include "WM_api.h"
56 #include "WM_types.h"
57
58 #include "ED_screen.h"
59 #include "ED_types.h"
60 #include "UI_interface.h"
61 #include "UI_resources.h"
62
63 #include "RNA_access.h"
64 #include "RNA_define.h"
65
66 #include "console_intern.h"
67
68 void console_history_free(SpaceConsole *sc, ConsoleLine *cl)
69 {
70         BLI_remlink(&sc->history, cl);
71         MEM_freeN(cl->line);
72         MEM_freeN(cl);
73 }
74 void console_scrollback_free(SpaceConsole *sc, ConsoleLine *cl)
75 {
76         BLI_remlink(&sc->scrollback, cl);
77         MEM_freeN(cl->line);
78         MEM_freeN(cl);
79 }
80
81 void console_scrollback_limit(SpaceConsole *sc)
82 {
83         int tot;
84         
85         if (U.scrollback < 32) U.scrollback= 128; // XXX - save in user defaults
86         
87         for(tot= BLI_countlist(&sc->scrollback); tot > U.scrollback; tot--)
88                 console_scrollback_free(sc, sc->scrollback.first);
89 }
90
91 static ConsoleLine * console_history_find(SpaceConsole *sc, const char *str, ConsoleLine *cl_ignore)
92 {
93         ConsoleLine *cl;
94
95         for(cl= sc->history.last; cl; cl= cl->prev) {
96                 if (cl==cl_ignore)
97                         continue;
98
99                 if(strcmp(str, cl->line)==0)
100                         return cl;
101         }
102
103         return NULL;
104 }
105
106 /* return 0 if no change made, clamps the range */
107 static int console_line_cursor_set(ConsoleLine *cl, int cursor)
108 {
109         int cursor_new;
110         
111         if(cursor < 0)                          cursor_new= 0;
112         else if(cursor > cl->len)       cursor_new= cl->len;
113         else                                            cursor_new= cursor;
114         
115         if(cursor_new == cl->cursor)
116                 return 0;
117         
118         cl->cursor= cursor_new;
119         return 1;
120 }
121
122 static ConsoleLine *console_lb_add__internal(ListBase *lb, ConsoleLine *from)
123 {
124         ConsoleLine *ci= MEM_callocN(sizeof(ConsoleLine), "ConsoleLine Add");
125         
126         if(from) {
127                 ci->line= BLI_strdup(from->line);
128                 ci->len= strlen(ci->line);
129                 ci->len_alloc= ci->len;
130                 
131                 ci->cursor= from->cursor;
132                 ci->type= from->type;
133         } else {
134                 ci->line= MEM_callocN(64, "console-in-line");
135                 ci->len_alloc= 64;
136                 ci->len= 0;
137         }
138         
139         BLI_addtail(lb, ci);
140         return ci;
141 }
142
143 static ConsoleLine *console_history_add(const bContext *C, ConsoleLine *from)
144 {
145         SpaceConsole *sc= CTX_wm_space_console(C);
146         
147         return console_lb_add__internal(&sc->history, from);
148 }
149
150 #if 0 /* may use later ? */
151 static ConsoleLine *console_scrollback_add(const bContext *C, ConsoleLine *from)
152 {
153         SpaceConsole *sc= CTX_wm_space_console(C);
154         
155         return console_lb_add__internal(&sc->scrollback, from);
156 }
157 #endif
158
159 static ConsoleLine *console_lb_add_str__internal(ListBase *lb, const bContext *C, char *str, int own)
160 {
161         ConsoleLine *ci= MEM_callocN(sizeof(ConsoleLine), "ConsoleLine Add");
162         if(own)         ci->line= str;
163         else            ci->line= BLI_strdup(str);
164         
165         ci->len = ci->len_alloc = strlen(str);
166         
167         BLI_addtail(lb, ci);
168         return ci;
169 }
170 ConsoleLine *console_history_add_str(const bContext *C, char *str, int own)
171 {
172         return console_lb_add_str__internal(&CTX_wm_space_console(C)->history, C, str, own);
173 }
174 ConsoleLine *console_scrollback_add_str(const bContext *C, char *str, int own)
175 {
176         return console_lb_add_str__internal(&CTX_wm_space_console(C)->scrollback, C, str, own);
177 }
178
179 ConsoleLine *console_history_verify(const bContext *C)
180 {
181         SpaceConsole *sc= CTX_wm_space_console(C);
182         ConsoleLine *ci= sc->history.last;
183         if(ci==NULL)
184                 ci= console_history_add(C, NULL);
185         
186         return ci;
187 }
188
189
190 static void console_line_verify_length(ConsoleLine *ci, int len)
191 {
192         /* resize the buffer if needed */
193         if(len >= ci->len_alloc) {
194                 int new_len= len * 2; /* new length */
195                 char *new_line= MEM_callocN(new_len, "console line");
196                 memcpy(new_line, ci->line, ci->len);
197                 MEM_freeN(ci->line);
198                 
199                 ci->line= new_line;
200                 ci->len_alloc= new_len;
201         }
202 }
203
204 static int console_line_insert(ConsoleLine *ci, char *str)
205 {
206         int len = strlen(str);
207         
208         if(len>0 && str[len-1]=='\n') {/* stop new lines being pasted at the end of lines */
209                 str[len-1]= '\0';
210                 len--;
211         }
212
213         if(len==0)
214                 return 0;
215         
216         console_line_verify_length(ci, len + ci->len);
217         
218         memmove(ci->line+ci->cursor+len, ci->line+ci->cursor, (ci->len - ci->cursor)+1);
219         memcpy(ci->line+ci->cursor, str, len);
220         
221         ci->len += len;
222         ci->cursor += len;
223         
224         return len;
225 }
226
227 static int console_edit_poll(bContext *C)
228 {
229         SpaceConsole *sc= CTX_wm_space_console(C);
230
231         if(!sc || sc->type != CONSOLE_TYPE_PYTHON)
232                 return 0;
233
234         return 1;
235 }
236
237 static int console_poll(bContext *C)
238 {
239         return (CTX_wm_space_console(C) != NULL);
240 }
241
242
243 /* static funcs for text editing */
244
245 /* similar to the text editor, with some not used. keep compatible */
246 static EnumPropertyItem move_type_items[]= {
247         {LINE_BEGIN, "LINE_BEGIN", 0, "Line Begin", ""},
248         {LINE_END, "LINE_END", 0, "Line End", ""},
249         {PREV_CHAR, "PREVIOUS_CHARACTER", 0, "Previous Character", ""},
250         {NEXT_CHAR, "NEXT_CHARACTER", 0, "Next Character", ""},
251         {PREV_WORD, "PREVIOUS_WORD", 0, "Previous Word", ""},
252         {NEXT_WORD, "NEXT_WORD", 0, "Next Word", ""},
253         {0, NULL, 0, NULL, NULL}};
254         
255 static int move_exec(bContext *C, wmOperator *op)
256 {
257         ConsoleLine *ci= console_history_verify(C);
258         
259         int type= RNA_enum_get(op->ptr, "type");
260         int done= 0;
261         
262         switch(type) {
263         case LINE_BEGIN:
264                 done= console_line_cursor_set(ci, 0);
265                 break;
266         case LINE_END:
267                 done= console_line_cursor_set(ci, INT_MAX);
268                 break;
269         case PREV_CHAR:
270                 done= console_line_cursor_set(ci, ci->cursor-1);
271                 break;
272         case NEXT_CHAR:
273                 done= console_line_cursor_set(ci, ci->cursor+1);
274                 break;
275         }
276         
277         if(done) {
278                 ED_area_tag_redraw(CTX_wm_area(C));
279         }
280         
281         return OPERATOR_FINISHED;
282 }
283
284 void CONSOLE_OT_move(wmOperatorType *ot)
285 {
286         /* identifiers */
287         ot->name= "Move Cursor";
288     ot->description= "Move cursor position.";
289         ot->idname= "CONSOLE_OT_move";
290         
291         /* api callbacks */
292         ot->exec= move_exec;
293         ot->poll= console_edit_poll;
294
295         /* flags */
296         ot->flag= OPTYPE_REGISTER;
297
298         /* properties */
299         RNA_def_enum(ot->srna, "type", move_type_items, LINE_BEGIN, "Type", "Where to move cursor to.");
300 }
301
302
303 static int insert_exec(bContext *C, wmOperator *op)
304 {
305         ConsoleLine *ci= console_history_verify(C);
306         char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0);
307         
308         int len= console_line_insert(ci, str);
309         
310         MEM_freeN(str);
311         
312         if(len==0)
313                 return OPERATOR_CANCELLED;
314                 
315         ED_area_tag_redraw(CTX_wm_area(C));
316         
317         return OPERATOR_FINISHED;
318 }
319
320 static int insert_invoke(bContext *C, wmOperator *op, wmEvent *event)
321 {
322         if(!RNA_property_is_set(op->ptr, "text")) {
323                 char str[2] = {event->ascii, '\0'};
324                 RNA_string_set(op->ptr, "text", str);
325         }
326         return insert_exec(C, op);
327 }
328
329 void CONSOLE_OT_insert(wmOperatorType *ot)
330 {
331         /* identifiers */
332         ot->name= "Insert";
333     ot->description= "Insert text at cursor position.";
334         ot->idname= "CONSOLE_OT_insert";
335         
336         /* api callbacks */
337         ot->exec= insert_exec;
338         ot->invoke= insert_invoke;
339         ot->poll= console_edit_poll;
340
341         /* flags */
342         ot->flag= OPTYPE_REGISTER;
343
344         /* properties */
345         RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");
346 }
347
348
349 static EnumPropertyItem delete_type_items[]= {
350         {DEL_NEXT_CHAR, "NEXT_CHARACTER", 0, "Next Character", ""},
351         {DEL_PREV_CHAR, "PREVIOUS_CHARACTER", 0, "Previous Character", ""},
352 //      {DEL_NEXT_WORD, "NEXT_WORD", 0, "Next Word", ""},
353 //      {DEL_PREV_WORD, "PREVIOUS_WORD", 0, "Previous Word", ""},
354         {0, NULL, 0, NULL, NULL}};
355
356 static int delete_exec(bContext *C, wmOperator *op)
357 {
358         
359         ConsoleLine *ci= console_history_verify(C);
360         
361         
362         int done = 0;
363
364         int type= RNA_enum_get(op->ptr, "type");
365         
366         if(ci->len==0) {
367                 return OPERATOR_CANCELLED;
368         }
369         
370         switch(type) {
371         case DEL_NEXT_CHAR:
372                 if(ci->cursor < ci->len) {
373                         memmove(ci->line + ci->cursor, ci->line + ci->cursor+1, (ci->len - ci->cursor)+1);
374                         ci->len--;
375                         done= 1;
376                 }
377                 break;
378         case DEL_PREV_CHAR:
379                 if(ci->cursor > 0) {
380                         ci->cursor--; /* same as above */
381                         memmove(ci->line + ci->cursor, ci->line + ci->cursor+1, (ci->len - ci->cursor)+1);
382                         ci->len--;
383                         done= 1;
384                 }
385                 break;
386         }
387         
388         if(!done)
389                 return OPERATOR_CANCELLED;
390         
391         ED_area_tag_redraw(CTX_wm_area(C));
392         
393         return OPERATOR_FINISHED;
394 }
395
396
397 void CONSOLE_OT_delete(wmOperatorType *ot)
398 {
399         /* identifiers */
400         ot->name= "Delete";
401     ot->description= "Delete text by cursor position.";
402         ot->idname= "CONSOLE_OT_delete";
403         
404         /* api callbacks */
405         ot->exec= delete_exec;
406         ot->poll= console_edit_poll;
407
408         /* flags */
409         ot->flag= OPTYPE_REGISTER;
410
411         /* properties */
412         RNA_def_enum(ot->srna, "type", delete_type_items, DEL_NEXT_CHAR, "Type", "Which part of the text to delete.");
413 }
414
415
416 /* the python exec operator uses this */
417 static int clear_exec(bContext *C, wmOperator *op)
418 {
419         SpaceConsole *sc= CTX_wm_space_console(C);
420         
421         short scrollback= RNA_boolean_get(op->ptr, "scrollback");
422         short history= RNA_boolean_get(op->ptr, "history");
423         
424         /*ConsoleLine *ci= */ console_history_verify(C);
425         
426         if(scrollback) { /* last item in mistory */
427                 while(sc->scrollback.first)
428                         console_scrollback_free(sc, sc->scrollback.first);
429         }
430         
431         if(history) {
432                 while(sc->history.first)
433                         console_history_free(sc, sc->history.first);
434         }
435         
436         ED_area_tag_redraw(CTX_wm_area(C));
437         
438         return OPERATOR_FINISHED;
439 }
440
441 void CONSOLE_OT_clear(wmOperatorType *ot)
442 {
443         /* identifiers */
444         ot->name= "Clear";
445     ot->description= "Clear text by type.";
446         ot->idname= "CONSOLE_OT_clear";
447         
448         /* api callbacks */
449         ot->exec= clear_exec;
450         ot->poll= console_edit_poll;
451
452         /* flags */
453         ot->flag= OPTYPE_REGISTER;
454         
455         /* properties */
456         RNA_def_boolean(ot->srna, "scrollback", 1, "Scrollback", "Clear the scrollback history");
457         RNA_def_boolean(ot->srna, "history", 0, "History", "Clear the command history");
458 }
459
460
461
462 /* the python exec operator uses this */
463 static int history_cycle_exec(bContext *C, wmOperator *op)
464 {
465         SpaceConsole *sc= CTX_wm_space_console(C);
466         ConsoleLine *ci= console_history_verify(C); /* TODO - stupid, just prevernts crashes when no command line */
467         
468         short reverse= RNA_boolean_get(op->ptr, "reverse"); /* assumes down, reverse is up */
469         
470         if(reverse) { /* last item in mistory */
471                 ci= sc->history.last;
472                 BLI_remlink(&sc->history, ci);
473                 BLI_addhead(&sc->history, ci);
474         }
475         else {
476                 ci= sc->history.first;
477                 BLI_remlink(&sc->history, ci);
478                 BLI_addtail(&sc->history, ci);
479         }
480         
481         ED_area_tag_redraw(CTX_wm_area(C));
482         
483         return OPERATOR_FINISHED;
484 }
485
486 void CONSOLE_OT_history_cycle(wmOperatorType *ot)
487 {
488         /* identifiers */
489         ot->name= "History Cycle";
490     ot->description= "Cycle through history.";
491         ot->idname= "CONSOLE_OT_history_cycle";
492         
493         /* api callbacks */
494         ot->exec= history_cycle_exec;
495         ot->poll= console_edit_poll;
496
497         /* flags */
498         ot->flag= OPTYPE_REGISTER;
499         
500         /* properties */
501         RNA_def_boolean(ot->srna, "reverse", 0, "Reverse", "reverse cycle history");
502 }
503
504
505 /* the python exec operator uses this */
506 static int history_append_exec(bContext *C, wmOperator *op)
507 {
508         ConsoleLine *ci= console_history_verify(C);
509         char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0); /* own this text in the new line, dont free */
510         int cursor= RNA_int_get(op->ptr, "current_character");
511         short rem_dupes= RNA_boolean_get(op->ptr, "remove_duplicates");
512
513         if(rem_dupes) {
514                 SpaceConsole *sc= CTX_wm_space_console(C);
515                 ConsoleLine *cl;
516
517                 while((cl= console_history_find(sc, ci->line, ci)))
518                         console_history_free(sc, cl);
519
520                 if(strcmp(str, ci->line)==0) {
521                         MEM_freeN(str);
522                         return OPERATOR_FINISHED;
523                 }
524         }
525
526         ci= console_history_add_str(C, str, 1); /* own the string */
527         console_line_cursor_set(ci, cursor);
528         
529         ED_area_tag_redraw(CTX_wm_area(C));
530         
531         return OPERATOR_FINISHED;
532 }
533
534 void CONSOLE_OT_history_append(wmOperatorType *ot)
535 {
536         /* identifiers */
537         ot->name= "History Append";
538     ot->description= "Append history at cursor position.";
539         ot->idname= "CONSOLE_OT_history_append";
540         
541         /* api callbacks */
542         ot->exec= history_append_exec;
543         ot->poll= console_edit_poll;
544
545         /* flags */
546         ot->flag= OPTYPE_REGISTER;
547         
548         /* properties */
549         RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");      
550         RNA_def_int(ot->srna, "current_character", 0, 0, INT_MAX, "Cursor", "The index of the cursor.", 0, 10000);
551         RNA_def_boolean(ot->srna, "remove_duplicates", 0, "Remove Duplicates", "Remove duplicate items in the history");
552 }
553
554
555 /* the python exec operator uses this */
556 static int scrollback_append_exec(bContext *C, wmOperator *op)
557 {
558         SpaceConsole *sc= CTX_wm_space_console(C);
559         ConsoleLine *ci= console_history_verify(C);
560         
561         char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0); /* own this text in the new line, dont free */
562         int type= RNA_enum_get(op->ptr, "type");
563         
564         ci= console_scrollback_add_str(C, str, 1); /* own the string */
565         ci->type= type;
566         
567         console_scrollback_limit(sc);
568         
569         ED_area_tag_redraw(CTX_wm_area(C));
570         
571         return OPERATOR_FINISHED;
572 }
573
574 void CONSOLE_OT_scrollback_append(wmOperatorType *ot)
575 {
576         /* defined in DNA_space_types.h */
577         static EnumPropertyItem console_line_type_items[] = {
578                 {CONSOLE_LINE_OUTPUT,   "OUTPUT", 0, "Output", ""},
579                 {CONSOLE_LINE_INPUT,    "INPUT", 0, "Input", ""},
580                 {CONSOLE_LINE_INFO,             "INFO", 0, "Information", ""},
581                 {CONSOLE_LINE_ERROR,    "ERROR", 0, "Error", ""},
582                 {0, NULL, 0, NULL, NULL}};
583
584         /* identifiers */
585         ot->name= "Scrollback Append";
586     ot->description= "Append scrollback text by type.";
587         ot->idname= "CONSOLE_OT_scrollback_append";
588         
589         /* api callbacks */
590         ot->exec= scrollback_append_exec;
591         ot->poll= console_edit_poll;
592
593         /* flags */
594         ot->flag= OPTYPE_REGISTER;
595         
596         /* properties */
597         RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");      
598         RNA_def_enum(ot->srna, "type", console_line_type_items, CONSOLE_LINE_OUTPUT, "Type", "Console output type.");
599 }
600
601
602 static int copy_exec(bContext *C, wmOperator *op)
603 {
604         SpaceConsole *sc= CTX_wm_space_console(C);
605
606         DynStr *buf_dyn= BLI_dynstr_new();
607         char *buf_str;
608         
609         ConsoleLine *cl;
610         
611         for(cl= sc->scrollback.first; cl; cl= cl->next) {
612                 BLI_dynstr_append(buf_dyn, cl->line);
613                 BLI_dynstr_append(buf_dyn, "\n");
614         }
615
616         buf_str= BLI_dynstr_get_cstring(buf_dyn);
617         BLI_dynstr_free(buf_dyn);
618
619         WM_clipboard_text_set(buf_str, 0);
620
621         MEM_freeN(buf_str);
622         return OPERATOR_FINISHED;
623 }
624
625 void CONSOLE_OT_copy(wmOperatorType *ot)
626 {
627         /* identifiers */
628         ot->name= "Copy to Clipboard";
629     ot->description= "Copy selected text to clipboard.";
630         ot->idname= "CONSOLE_OT_copy";
631
632         /* api callbacks */
633         ot->poll= console_edit_poll;
634         ot->exec= copy_exec;
635
636         /* flags */
637         ot->flag= OPTYPE_REGISTER;
638
639         /* properties */
640 }
641
642 static int paste_exec(bContext *C, wmOperator *op)
643 {
644         ConsoleLine *ci= console_history_verify(C);
645
646         char *buf_str= WM_clipboard_text_get(0);
647
648         if(buf_str==NULL)
649                 return OPERATOR_CANCELLED;
650
651         console_line_insert(ci, buf_str); /* TODO - Multiline copy?? */
652
653         MEM_freeN(buf_str);
654
655         ED_area_tag_redraw(CTX_wm_area(C));
656
657         return OPERATOR_FINISHED;
658 }
659
660 void CONSOLE_OT_paste(wmOperatorType *ot)
661 {
662         /* identifiers */
663         ot->name= "Paste from Clipboard";
664     ot->description= "Paste text from clipboard.";
665         ot->idname= "CONSOLE_OT_paste";
666
667         /* api callbacks */
668         ot->poll= console_edit_poll;
669         ot->exec= paste_exec;
670
671         /* flags */
672         ot->flag= OPTYPE_REGISTER;
673
674         /* properties */
675 }
676
677 static int zoom_exec(bContext *C, wmOperator *op)
678 {
679         SpaceConsole *sc= CTX_wm_space_console(C);
680         
681         int delta= RNA_int_get(op->ptr, "delta");
682         
683         sc->lheight += delta;
684         CLAMP(sc->lheight, 8, 32);
685         
686         ED_area_tag_redraw(CTX_wm_area(C));
687         
688         return OPERATOR_FINISHED;
689 }
690
691
692 void CONSOLE_OT_zoom(wmOperatorType *ot)
693 {
694         /* identifiers */
695         ot->name= "Console Zoom";
696     /*optionals - 
697       "Zoom view font." */
698     ot->description= "Zoom screen area.";
699         ot->idname= "CONSOLE_OT_zoom";
700         
701         /* api callbacks */
702         ot->exec= zoom_exec;
703         ot->poll= console_poll;
704
705         /* flags */
706         /* ot->flag= OPTYPE_REGISTER; */ /* super annoying */
707         
708         /* properties */
709         RNA_def_int(ot->srna, "delta", 0, 0, INT_MAX, "Delta", "Scale the view font.", 0, 1000);
710 }