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