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