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