svn merge https://svn.blender.org/svnroot/bf-blender/trunk/blender -r20937:21899
[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_windowmanager_types.h"
41
42 #include "BLI_blenlib.h"
43 #include "PIL_time.h"
44
45 #include "BKE_utildefines.h"
46 #include "BKE_context.h"
47 #include "BKE_depsgraph.h"
48 #include "BKE_global.h"
49 #include "BKE_library.h"
50 #include "BKE_main.h"
51 #include "BKE_report.h"
52
53 #include "WM_api.h"
54 #include "WM_types.h"
55
56 #include "ED_screen.h"
57 #include "ED_types.h"
58 #include "UI_interface.h"
59 #include "UI_resources.h"
60
61 #include "RNA_access.h"
62 #include "RNA_define.h"
63
64 #include "console_intern.h"
65
66 void console_history_free(SpaceConsole *sc, ConsoleLine *cl)
67 {
68         BLI_remlink(&sc->history, cl);
69         MEM_freeN(cl->line);
70         MEM_freeN(cl);
71 }
72 void console_scrollback_free(SpaceConsole *sc, ConsoleLine *cl)
73 {
74         BLI_remlink(&sc->scrollback, cl);
75         MEM_freeN(cl->line);
76         MEM_freeN(cl);
77 }
78
79 void console_scrollback_limit(SpaceConsole *sc)
80 {
81         int tot;
82         for(tot= BLI_countlist(&sc->scrollback); tot > CONSOLE_SCROLLBACK_LIMIT; tot--)
83                 console_scrollback_free(sc, sc->scrollback.first);
84 }
85
86 /* return 0 if no change made, clamps the range */
87 static int console_line_cursor_set(ConsoleLine *cl, int cursor)
88 {
89         int cursor_new;
90         
91         if(cursor < 0)                          cursor_new= 0;
92         else if(cursor > cl->len)       cursor_new= cl->len;
93         else                                            cursor_new= cursor;
94         
95         if(cursor_new == cl->cursor)
96                 return 0;
97         
98         cl->cursor= cursor_new;
99         return 1;
100 }
101
102 static ConsoleLine *console_lb_add__internal(ListBase *lb, ConsoleLine *from)
103 {
104         ConsoleLine *ci= MEM_callocN(sizeof(ConsoleLine), "ConsoleLine Add");
105         
106         if(from) {
107                 ci->line= BLI_strdup(from->line);
108                 ci->len= strlen(ci->line);
109                 ci->len_alloc= ci->len;
110                 
111                 ci->cursor= from->cursor;
112                 ci->type= from->type;
113         } else {
114                 ci->line= MEM_callocN(64, "console-in-line");
115                 ci->len_alloc= 64;
116                 ci->len= 0;
117         }
118         
119         BLI_addtail(lb, ci);
120         return ci;
121 }
122
123 static ConsoleLine *console_history_add(const bContext *C, ConsoleLine *from)
124 {
125         SpaceConsole *sc= CTX_wm_space_console(C);
126         
127         return console_lb_add__internal(&sc->history, from);
128 }
129
130 #if 0 /* may use later ? */
131 static ConsoleLine *console_scrollback_add(const bContext *C, ConsoleLine *from)
132 {
133         SpaceConsole *sc= CTX_wm_space_console(C);
134         
135         return console_lb_add__internal(&sc->scrollback, from);
136 }
137 #endif
138
139 static ConsoleLine *console_lb_add_str__internal(ListBase *lb, const bContext *C, char *str, int own)
140 {
141         ConsoleLine *ci= MEM_callocN(sizeof(ConsoleLine), "ConsoleLine Add");
142         if(own)         ci->line= str;
143         else            ci->line= BLI_strdup(str);
144         
145         ci->len = ci->len_alloc = strlen(str);
146         
147         BLI_addtail(lb, ci);
148         return ci;
149 }
150 ConsoleLine *console_history_add_str(const bContext *C, char *str, int own)
151 {
152         return console_lb_add_str__internal(&CTX_wm_space_console(C)->history, C, str, own);
153 }
154 ConsoleLine *console_scrollback_add_str(const bContext *C, char *str, int own)
155 {
156         return console_lb_add_str__internal(&CTX_wm_space_console(C)->scrollback, C, str, own);
157 }
158
159 ConsoleLine *console_history_verify(const bContext *C)
160 {
161         SpaceConsole *sc= CTX_wm_space_console(C);
162         ConsoleLine *ci= sc->history.last;
163         if(ci==NULL)
164                 ci= console_history_add(C, NULL);
165         
166         return ci;
167 }
168
169
170 static void console_line_verify_length(ConsoleLine *ci, int len)
171 {
172         /* resize the buffer if needed */
173         if(len > ci->len_alloc) {
174                 int new_len= len * 2; /* new length */
175                 char *new_line= MEM_callocN(new_len, "console line");
176                 memcpy(new_line, ci->line, ci->len);
177                 MEM_freeN(ci->line);
178                 
179                 ci->line= new_line;
180                 ci->len_alloc= new_len;
181         }
182 }
183
184 static int console_line_insert(ConsoleLine *ci, char *str)
185 {
186         int len = strlen(str);
187         
188         if(len==0)
189                 return 0;
190         
191         console_line_verify_length(ci, len + ci->len);
192         
193         memmove(ci->line+ci->cursor+len, ci->line+ci->cursor, (ci->len - ci->cursor)+1);
194         memcpy(ci->line+ci->cursor, str, len);
195         
196         ci->len += len;
197         ci->cursor += len;
198         
199         return len;
200 }
201
202 static int console_edit_poll(bContext *C)
203 {
204         SpaceConsole *sc= CTX_wm_space_console(C);
205
206         if(!sc || sc->type != CONSOLE_TYPE_PYTHON)
207                 return 0;
208
209         return 1;
210 }
211
212
213 /* static funcs for text editing */
214
215 /* similar to the text editor, with some not used. keep compatible */
216 static EnumPropertyItem move_type_items[]= {
217         {LINE_BEGIN, "LINE_BEGIN", 0, "Line Begin", ""},
218         {LINE_END, "LINE_END", 0, "Line End", ""},
219         {PREV_CHAR, "PREVIOUS_CHARACTER", 0, "Previous Character", ""},
220         {NEXT_CHAR, "NEXT_CHARACTER", 0, "Next Character", ""},
221         {PREV_WORD, "PREVIOUS_WORD", 0, "Previous Word", ""},
222         {NEXT_WORD, "NEXT_WORD", 0, "Next Word", ""},
223         {0, NULL, 0, NULL, NULL}};
224         
225 static int move_exec(bContext *C, wmOperator *op)
226 {
227         ConsoleLine *ci= console_history_verify(C);
228         
229         int type= RNA_enum_get(op->ptr, "type");
230         int done= 0;
231         
232         switch(type) {
233         case LINE_BEGIN:
234                 done= console_line_cursor_set(ci, 0);
235                 break;
236         case LINE_END:
237                 done= console_line_cursor_set(ci, INT_MAX);
238                 break;
239         case PREV_CHAR:
240                 done= console_line_cursor_set(ci, ci->cursor-1);
241                 break;
242         case NEXT_CHAR:
243                 done= console_line_cursor_set(ci, ci->cursor+1);
244                 break;
245         }
246         
247         if(done) {
248                 ED_area_tag_redraw(CTX_wm_area(C));
249         }
250         
251         return OPERATOR_FINISHED;
252 }
253
254 void CONSOLE_OT_move(wmOperatorType *ot)
255 {
256         /* identifiers */
257         ot->name= "Move Cursor";
258         ot->idname= "CONSOLE_OT_move";
259         
260         /* api callbacks */
261         ot->exec= move_exec;
262         ot->poll= console_edit_poll;
263
264         /* flags */
265         ot->flag= OPTYPE_REGISTER;
266
267         /* properties */
268         RNA_def_enum(ot->srna, "type", move_type_items, LINE_BEGIN, "Type", "Where to move cursor to.");
269 }
270
271
272 static int insert_exec(bContext *C, wmOperator *op)
273 {
274         ConsoleLine *ci= console_history_verify(C);
275         char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0);
276         
277         int len= console_line_insert(ci, str);
278         
279         MEM_freeN(str);
280         
281         if(len==0)
282                 return OPERATOR_CANCELLED;
283                 
284         ED_area_tag_redraw(CTX_wm_area(C));
285         
286         return OPERATOR_FINISHED;
287 }
288
289 static int insert_invoke(bContext *C, wmOperator *op, wmEvent *event)
290 {
291         if(!RNA_property_is_set(op->ptr, "text")) {
292                 char str[2] = {event->ascii, '\0'};
293                 RNA_string_set(op->ptr, "text", str);
294         }
295         return insert_exec(C, op);
296 }
297
298 void CONSOLE_OT_insert(wmOperatorType *ot)
299 {
300         /* identifiers */
301         ot->name= "Insert";
302         ot->idname= "CONSOLE_OT_insert";
303         
304         /* api callbacks */
305         ot->exec= insert_exec;
306         ot->invoke= insert_invoke;
307         ot->poll= console_edit_poll;
308
309         /* flags */
310         ot->flag= OPTYPE_REGISTER;
311
312         /* properties */
313         RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");
314 }
315
316
317 static EnumPropertyItem delete_type_items[]= {
318         {DEL_NEXT_CHAR, "NEXT_CHARACTER", 0, "Next Character", ""},
319         {DEL_PREV_CHAR, "PREVIOUS_CHARACTER", 0, "Previous Character", ""},
320 //      {DEL_NEXT_WORD, "NEXT_WORD", 0, "Next Word", ""},
321 //      {DEL_PREV_WORD, "PREVIOUS_WORD", 0, "Previous Word", ""},
322         {0, NULL, 0, NULL, NULL}};
323
324 static int delete_exec(bContext *C, wmOperator *op)
325 {
326         
327         ConsoleLine *ci= console_history_verify(C);
328         
329         
330         int done = 0;
331
332         int type= RNA_enum_get(op->ptr, "type");
333         
334         if(ci->len==0) {
335                 return OPERATOR_CANCELLED;
336         }
337         
338         switch(type) {
339         case DEL_NEXT_CHAR:
340                 if(ci->cursor < ci->len) {
341                         memmove(ci->line + ci->cursor, ci->line + ci->cursor+1, (ci->len - ci->cursor)+1);
342                         ci->len--;
343                         done= 1;
344                 }
345                 break;
346         case DEL_PREV_CHAR:
347                 if(ci->cursor > 0) {
348                         ci->cursor--; /* same as above */
349                         memmove(ci->line + ci->cursor, ci->line + ci->cursor+1, (ci->len - ci->cursor)+1);
350                         ci->len--;
351                         done= 1;
352                 }
353                 break;
354         }
355         
356         if(!done)
357                 return OPERATOR_CANCELLED;
358         
359         ED_area_tag_redraw(CTX_wm_area(C));
360         
361         return OPERATOR_FINISHED;
362 }
363
364
365 void CONSOLE_OT_delete(wmOperatorType *ot)
366 {
367         /* identifiers */
368         ot->name= "Delete";
369         ot->idname= "CONSOLE_OT_delete";
370         
371         /* api callbacks */
372         ot->exec= delete_exec;
373         ot->poll= console_edit_poll;
374
375         /* flags */
376         ot->flag= OPTYPE_REGISTER;
377
378         /* properties */
379         RNA_def_enum(ot->srna, "type", delete_type_items, DEL_NEXT_CHAR, "Type", "Which part of the text to delete.");
380 }
381
382
383 /* the python exec operator uses this */
384 static int clear_exec(bContext *C, wmOperator *op)
385 {
386         SpaceConsole *sc= CTX_wm_space_console(C);
387         
388         short scrollback= RNA_boolean_get(op->ptr, "scrollback");
389         short history= RNA_boolean_get(op->ptr, "history");
390         
391         /*ConsoleLine *ci= */ console_history_verify(C);
392         
393         if(scrollback) { /* last item in mistory */
394                 while(sc->scrollback.first)
395                         console_scrollback_free(sc, sc->scrollback.first);
396         }
397         
398         if(history) {
399                 while(sc->history.first)
400                         console_history_free(sc, sc->history.first);
401         }
402         
403         ED_area_tag_redraw(CTX_wm_area(C));
404         
405         return OPERATOR_FINISHED;
406 }
407
408 void CONSOLE_OT_clear(wmOperatorType *ot)
409 {
410         /* identifiers */
411         ot->name= "Clear";
412         ot->idname= "CONSOLE_OT_clear";
413         
414         /* api callbacks */
415         ot->exec= clear_exec;
416         ot->poll= console_edit_poll;
417
418         /* flags */
419         ot->flag= OPTYPE_REGISTER;
420         
421         /* properties */
422         RNA_def_boolean(ot->srna, "scrollback", 1, "Scrollback", "Clear the scrollback history");
423         RNA_def_boolean(ot->srna, "history", 0, "History", "Clear the command history");
424 }
425
426
427
428 /* the python exec operator uses this */
429 static int history_cycle_exec(bContext *C, wmOperator *op)
430 {
431         SpaceConsole *sc= CTX_wm_space_console(C);
432         ConsoleLine *ci= console_history_verify(C); /* TODO - stupid, just prevernts crashes when no command line */
433         
434         short reverse= RNA_boolean_get(op->ptr, "reverse"); /* assumes down, reverse is up */
435         
436         if(reverse) { /* last item in mistory */
437                 ci= sc->history.last;
438                 BLI_remlink(&sc->history, ci);
439                 BLI_addhead(&sc->history, ci);
440         }
441         else {
442                 ci= sc->history.first;
443                 BLI_remlink(&sc->history, ci);
444                 BLI_addtail(&sc->history, ci);
445         }
446         
447         ED_area_tag_redraw(CTX_wm_area(C));
448         
449         return OPERATOR_FINISHED;
450 }
451
452 void CONSOLE_OT_history_cycle(wmOperatorType *ot)
453 {
454         /* identifiers */
455         ot->name= "History Cycle";
456         ot->idname= "CONSOLE_OT_history_cycle";
457         
458         /* api callbacks */
459         ot->exec= history_cycle_exec;
460         ot->poll= console_edit_poll;
461
462         /* flags */
463         ot->flag= OPTYPE_REGISTER;
464         
465         /* properties */
466         RNA_def_boolean(ot->srna, "reverse", 0, "Reverse", "reverse cycle history");
467 }
468
469
470 /* the python exec operator uses this */
471 static int history_append_exec(bContext *C, wmOperator *op)
472 {
473         ConsoleLine *ci= console_history_verify(C);
474         
475         
476         char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0); /* own this text in the new line, dont free */
477         int cursor= RNA_int_get(op->ptr, "current_character");
478         
479         ci= console_history_add_str(C, str, 1); /* own the string */
480         console_line_cursor_set(ci, cursor);
481         
482         ED_area_tag_redraw(CTX_wm_area(C));
483         
484         return OPERATOR_FINISHED;
485 }
486
487 void CONSOLE_OT_history_append(wmOperatorType *ot)
488 {
489         /* identifiers */
490         ot->name= "History Append";
491         ot->idname= "CONSOLE_OT_history_append";
492         
493         /* api callbacks */
494         ot->exec= history_append_exec;
495         ot->poll= console_edit_poll;
496
497         /* flags */
498         ot->flag= OPTYPE_REGISTER;
499         
500         /* properties */
501         RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");      
502         RNA_def_int(ot->srna, "current_character", 0, 0, INT_MAX, "Cursor", "The index of the cursor.", 0, 10000);
503 }
504
505
506 /* the python exec operator uses this */
507 static int scrollback_append_exec(bContext *C, wmOperator *op)
508 {
509         SpaceConsole *sc= CTX_wm_space_console(C);
510         ConsoleLine *ci= console_history_verify(C);
511         
512         char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0); /* own this text in the new line, dont free */
513         int type= RNA_enum_get(op->ptr, "type");
514         
515         ci= console_scrollback_add_str(C, str, 1); /* own the string */
516         ci->type= type;
517         
518         console_scrollback_limit(sc);
519         
520         ED_area_tag_redraw(CTX_wm_area(C));
521         
522         return OPERATOR_FINISHED;
523 }
524
525 void CONSOLE_OT_scrollback_append(wmOperatorType *ot)
526 {
527         /* defined in DNA_space_types.h */
528         static EnumPropertyItem console_line_type_items[] = {
529                 {CONSOLE_LINE_OUTPUT,   "OUTPUT", 0, "Output", ""},
530                 {CONSOLE_LINE_INPUT,    "INPUT", 0, "Input", ""},
531                 {CONSOLE_LINE_INFO,             "INFO", 0, "Information", ""},
532                 {CONSOLE_LINE_ERROR,    "ERROR", 0, "Error", ""},
533                 {0, NULL, 0, NULL, NULL}};
534
535         /* identifiers */
536         ot->name= "Scrollback Append";
537         ot->idname= "CONSOLE_OT_scrollback_append";
538         
539         /* api callbacks */
540         ot->exec= scrollback_append_exec;
541         ot->poll= console_edit_poll;
542
543         /* flags */
544         ot->flag= OPTYPE_REGISTER;
545         
546         /* properties */
547         RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");      
548         RNA_def_enum(ot->srna, "type", console_line_type_items, CONSOLE_LINE_OUTPUT, "Type", "Console output type.");
549 }
550
551 static int zoom_exec(bContext *C, wmOperator *op)
552 {
553         SpaceConsole *sc= CTX_wm_space_console(C);
554         
555         int delta= RNA_int_get(op->ptr, "delta");
556         
557         sc->lheight += delta;
558         CLAMP(sc->lheight, 8, 32);
559         
560         ED_area_tag_redraw(CTX_wm_area(C));
561         
562         return OPERATOR_FINISHED;
563 }
564
565
566 void CONSOLE_OT_zoom(wmOperatorType *ot)
567 {
568         /* identifiers */
569         ot->name= "Console Zoom";
570         ot->idname= "CONSOLE_OT_zoom";
571         
572         /* api callbacks */
573         ot->exec= zoom_exec;
574
575         /* flags */
576         /* ot->flag= OPTYPE_REGISTER; */ /* super annoying */
577         
578         /* properties */
579         RNA_def_int(ot->srna, "delta", 0, 0, INT_MAX, "Delta", "Scale the view font.", 0, 1000);
580 }