static int console_indent_exec(bContext *C, wmOperator *UNUSED(op)) { SpaceConsole *sc = CTX_wm_space_console(C); ARegion *ar = CTX_wm_region(C); ConsoleLine *ci = console_history_verify(C); int spaces; int len; for (spaces = 0; spaces < ci->len; spaces++) { if (ci->line[spaces] != ' ') break; } len = TAB_LENGTH - spaces % TAB_LENGTH; console_line_verify_length(ci, ci->len + len); memmove(ci->line + len, ci->line, ci->len + 1); memset(ci->line, ' ', len); ci->len += len; BLI_assert(ci->len >= 0); console_line_cursor_set(ci, ci->cursor + len); console_select_offset(sc, len); console_textview_update_rect(sc, ar); ED_area_tag_redraw(CTX_wm_area(C)); console_scroll_bottom(ar); return OPERATOR_FINISHED; }
/* the python exec operator uses this */ static int console_scrollback_append_exec(bContext *C, wmOperator *op) { SpaceConsole *sc = CTX_wm_space_console(C); ARegion *ar = CTX_wm_region(C); ConsoleLine *ci; char *str = RNA_string_get_alloc(op->ptr, "text", NULL, 0); /* own this text in the new line, don't free */ int type = RNA_enum_get(op->ptr, "type"); console_history_verify(C); ci = console_scrollback_add_str(sc, str, 1); /* own the string */ ci->type = type; console_scrollback_limit(sc); /* 'ar' can be null depending on the operator that runs * rendering with invoke default for eg causes this */ if (ar) { console_textview_update_rect(sc, ar); } ED_area_tag_redraw(CTX_wm_area(C)); return OPERATOR_FINISHED; }
static int console_insert_exec(bContext *C, wmOperator *op) { SpaceConsole *sc = CTX_wm_space_console(C); ARegion *ar = CTX_wm_region(C); ConsoleLine *ci = console_history_verify(C); char *str = RNA_string_get_alloc(op->ptr, "text", NULL, 0); int len; if (str[0] == '\t' && str[1] == '\0') { len = TAB_LENGTH; MEM_freeN(str); str = MEM_mallocN(len + 1, "insert_exec"); memset(str, ' ', len); str[len] = '\0'; } len = console_line_insert(ci, str); MEM_freeN(str); if (len == 0) { return OPERATOR_CANCELLED; } else { console_select_offset(sc, len); } console_textview_update_rect(sc, ar); ED_area_tag_redraw(CTX_wm_area(C)); console_scroll_bottom(ar); return OPERATOR_FINISHED; }
static void console_history_debug(const bContext *C) { SpaceConsole *sc = CTX_wm_space_console(C); console_lb_debug__internal(&sc->history); }
/* the python exec operator uses this */ static int history_append_exec(bContext *C, wmOperator *op) { SpaceConsole *sc= CTX_wm_space_console(C); ScrArea *sa= CTX_wm_area(C); ConsoleLine *ci= console_history_verify(C); char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0); /* own this text in the new line, dont free */ int cursor= RNA_int_get(op->ptr, "current_character"); short rem_dupes= RNA_boolean_get(op->ptr, "remove_duplicates"); int prev_len= ci->len; if(rem_dupes) { ConsoleLine *cl; while((cl= console_history_find(sc, ci->line, ci))) console_history_free(sc, cl); if(strcmp(str, ci->line)==0) { MEM_freeN(str); return OPERATOR_FINISHED; } } ci= console_history_add_str(sc, str, 1); /* own the string */ console_select_offset(sc, ci->len - prev_len); console_line_cursor_set(ci, cursor); ED_area_tag_redraw(sa); return OPERATOR_FINISHED; }
/* the python exec operator uses this */ static int console_clear_exec(bContext *C, wmOperator *op) { SpaceConsole *sc = CTX_wm_space_console(C); ARegion *ar = CTX_wm_region(C); const bool scrollback = RNA_boolean_get(op->ptr, "scrollback"); const bool history = RNA_boolean_get(op->ptr, "history"); /*ConsoleLine *ci = */ console_history_verify(C); if (scrollback) { /* last item in mistory */ while (sc->scrollback.first) console_scrollback_free(sc, sc->scrollback.first); } if (history) { while (sc->history.first) console_history_free(sc, sc->history.first); console_history_verify(C); } console_textview_update_rect(sc, ar); ED_area_tag_redraw(CTX_wm_area(C)); return OPERATOR_FINISHED; }
static int console_copy_exec(bContext *C, wmOperator *UNUSED(op)) { SpaceConsole *sc = CTX_wm_space_console(C); DynStr *buf_dyn; char *buf_str; ConsoleLine *cl; int sel[2]; int offset = 0; ConsoleLine cl_dummy = {NULL}; if (sc->sel_start == sc->sel_end) return OPERATOR_CANCELLED; console_scrollback_prompt_begin(sc, &cl_dummy); for (cl = sc->scrollback.first; cl; cl = cl->next) { offset += cl->len + 1; } if (offset == 0) { console_scrollback_prompt_end(sc, &cl_dummy); return OPERATOR_CANCELLED; } buf_dyn = BLI_dynstr_new(); offset -= 1; sel[0] = offset - sc->sel_end; sel[1] = offset - sc->sel_start; for (cl = sc->scrollback.first; cl; cl = cl->next) { if (sel[0] <= cl->len && sel[1] >= 0) { int sta = max_ii(sel[0], 0); int end = min_ii(sel[1], cl->len); if (BLI_dynstr_get_len(buf_dyn)) BLI_dynstr_append(buf_dyn, "\n"); BLI_dynstr_nappend(buf_dyn, cl->line + sta, end - sta); } sel[0] -= cl->len + 1; sel[1] -= cl->len + 1; } buf_str = BLI_dynstr_get_cstring(buf_dyn); BLI_dynstr_free(buf_dyn); WM_clipboard_text_set(buf_str, 0); MEM_freeN(buf_str); console_scrollback_prompt_end(sc, &cl_dummy); return OPERATOR_FINISHED; }
ConsoleLine *console_history_verify(const bContext *C) { SpaceConsole *sc = CTX_wm_space_console(C); ConsoleLine *ci = sc->history.last; if (ci == NULL) ci = console_history_add(sc, NULL); return ci; }
/* the python exec operator uses this */ static int console_history_cycle_exec(bContext *C, wmOperator *op) { SpaceConsole *sc = CTX_wm_space_console(C); ARegion *ar = CTX_wm_region(C); ConsoleLine *ci = console_history_verify(C); /* TODO - stupid, just prevents crashes when no command line */ const bool reverse = RNA_boolean_get(op->ptr, "reverse"); /* assumes down, reverse is up */ int prev_len = ci->len; /* keep a copy of the line above so when history is cycled * this is the only function that needs to know about the double-up */ if (ci->prev) { ConsoleLine *ci_prev = (ConsoleLine *)ci->prev; if (STREQ(ci->line, ci_prev->line)) console_history_free(sc, ci_prev); } if (reverse) { /* last item in history */ ci = sc->history.last; BLI_remlink(&sc->history, ci); BLI_addhead(&sc->history, ci); } else { ci = sc->history.first; BLI_remlink(&sc->history, ci); BLI_addtail(&sc->history, ci); } { /* add a duplicate of the new arg and remove all other instances */ ConsoleLine *cl; while ((cl = console_history_find(sc, ci->line, ci))) console_history_free(sc, cl); console_history_add(sc, (ConsoleLine *)sc->history.last); } ci = sc->history.last; console_select_offset(sc, ci->len - prev_len); /* could be wrapped so update scroll rect */ console_textview_update_rect(sc, ar); ED_area_tag_redraw(CTX_wm_area(C)); console_scroll_bottom(ar); return OPERATOR_FINISHED; }
static int delete_exec(bContext *C, wmOperator *op) { SpaceConsole *sc= CTX_wm_space_console(C); ARegion *ar= CTX_wm_region(C); ConsoleLine *ci= console_history_verify(C); const short type= RNA_enum_get(op->ptr, "type"); int done = 0; if(ci->len==0) { return OPERATOR_CANCELLED; } switch(type) { case DEL_NEXT_CHAR: if(ci->cursor < ci->len) { memmove(ci->line + ci->cursor, ci->line + ci->cursor+1, (ci->len - ci->cursor)+1); ci->len--; done= 1; } break; case DEL_PREV_CHAR: if(ci->cursor > 0) { ci->cursor--; /* same as above */ memmove(ci->line + ci->cursor, ci->line + ci->cursor+1, (ci->len - ci->cursor)+1); ci->len--; done= 1; } break; } if(!done) { return OPERATOR_CANCELLED; } else { console_select_offset(sc, -1); } console_textview_update_rect(sc, ar); ED_area_tag_redraw(CTX_wm_area(C)); return OPERATOR_FINISHED; }
static int console_modal_select_invoke(bContext *C, wmOperator *op, const wmEvent *event) { SpaceConsole *sc = CTX_wm_space_console(C); // ARegion *ar = CTX_wm_region(C); SetConsoleCursor *scu; op->customdata = MEM_callocN(sizeof(SetConsoleCursor), "SetConsoleCursor"); scu = op->customdata; scu->sel_old[0] = sc->sel_start; scu->sel_old[1] = sc->sel_end; scu->sel_init = INT_MAX; WM_event_add_modal_handler(C, op); console_modal_select_apply(C, op, event); return OPERATOR_RUNNING_MODAL; }
static void console_modal_select_apply(bContext *C, wmOperator *op, const wmEvent *event) { SpaceConsole *sc = CTX_wm_space_console(C); ARegion *ar = CTX_wm_region(C); SetConsoleCursor *scu = op->customdata; int mval[2]; int sel_prev[2]; mval[0] = event->mval[0]; mval[1] = event->mval[1]; sel_prev[0] = sc->sel_start; sel_prev[1] = sc->sel_end; console_cursor_set_to_pos(sc, ar, scu, mval, true); /* only redraw if the selection changed */ if (sel_prev[0] != sc->sel_start || sel_prev[1] != sc->sel_end) { ED_area_tag_redraw(CTX_wm_area(C)); } }
/* the python exec operator uses this */ static int scrollback_append_exec(bContext *C, wmOperator *op) { SpaceConsole *sc= CTX_wm_space_console(C); ARegion *ar= CTX_wm_region(C); ConsoleLine *ci; char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0); /* own this text in the new line, dont free */ int type= RNA_enum_get(op->ptr, "type"); console_history_verify(C); ci= console_scrollback_add_str(sc, str, 1); /* own the string */ ci->type= type; console_scrollback_limit(sc); console_textview_update_rect(sc, ar); ED_area_tag_redraw(CTX_wm_area(C)); return OPERATOR_FINISHED; }
static int console_clear_line_exec(bContext *C, wmOperator *UNUSED(op)) { SpaceConsole *sc = CTX_wm_space_console(C); ARegion *ar = CTX_wm_region(C); ConsoleLine *ci = console_history_verify(C); if (ci->len == 0) { return OPERATOR_CANCELLED; } console_history_add(C, ci); console_history_add(C, NULL); console_textview_update_rect(sc, ar); ED_area_tag_redraw(CTX_wm_area(C)); console_scroll_bottom(ar); return OPERATOR_FINISHED; }
static int console_paste_exec(bContext *C, wmOperator *UNUSED(op)) { SpaceConsole *sc = CTX_wm_space_console(C); ARegion *ar = CTX_wm_region(C); ConsoleLine *ci = console_history_verify(C); int buf_len; char *buf_str = WM_clipboard_text_get(false, &buf_len); char *buf_step, *buf_next; if (buf_str == NULL) return OPERATOR_CANCELLED; buf_step = buf_str; while ((buf_next = buf_step) && buf_next[0] != '\0') { buf_step = strchr(buf_next, '\n'); if (buf_step) { *buf_step = '\0'; buf_step++; } if (buf_next != buf_str) { WM_operator_name_call(C, "CONSOLE_OT_execute", WM_OP_EXEC_DEFAULT, NULL); ci = console_history_verify(C); } console_select_offset(sc, console_line_insert(ci, buf_next)); } MEM_freeN(buf_str); console_textview_update_rect(sc, ar); ED_area_tag_redraw(CTX_wm_area(C)); console_scroll_bottom(ar); return OPERATOR_FINISHED; }
/* the python exec operator uses this */ static int console_history_append_exec(bContext *C, wmOperator *op) { SpaceConsole *sc = CTX_wm_space_console(C); ARegion *ar = CTX_wm_region(C); ScrArea *sa = CTX_wm_area(C); ConsoleLine *ci = console_history_verify(C); char *str = RNA_string_get_alloc(op->ptr, "text", NULL, 0); /* own this text in the new line, don't free */ int cursor = RNA_int_get(op->ptr, "current_character"); const bool rem_dupes = RNA_boolean_get(op->ptr, "remove_duplicates"); int prev_len = ci->len; if (rem_dupes) { ConsoleLine *cl; while ((cl = console_history_find(sc, ci->line, ci))) console_history_free(sc, cl); if (STREQ(str, ci->line)) { MEM_freeN(str); return OPERATOR_FINISHED; } } ci = console_history_add_str(sc, str, 1); /* own the string */ console_select_offset(sc, ci->len - prev_len); console_line_cursor_set(ci, cursor); ED_area_tag_redraw(sa); /* when calling render modally this can be NULL when calling: * bpy.ops.render.render('INVOKE_DEFAULT') */ if (ar) { console_scroll_bottom(ar); } return OPERATOR_FINISHED; }
/* return 0 if no change made, clamps the range */ static bool console_line_cursor_set(ConsoleLine *cl, int cursor) { int cursor_new; if (cursor < 0) cursor_new = 0; else if (cursor > cl->len) cursor_new = cl->len; else cursor_new = cursor; if (cursor_new == cl->cursor) { return false; } cl->cursor = cursor_new; return true; } #if 0 // XXX unused static void console_lb_debug__internal(ListBase *lb) { ConsoleLine *cl; printf("%d: ", BLI_listbase_count(lb)); for (cl = lb->first; cl; cl = cl->next) printf("<%s> ", cl->line); printf("\n"); } static void console_history_debug(const bContext *C) { SpaceConsole *sc = CTX_wm_space_console(C); console_lb_debug__internal(&sc->history); } #endif static ConsoleLine *console_lb_add__internal(ListBase *lb, ConsoleLine *from) { ConsoleLine *ci = MEM_callocN(sizeof(ConsoleLine), "ConsoleLine Add"); if (from) { BLI_assert(strlen(from->line) == from->len); ci->line = BLI_strdupn(from->line, from->len); ci->len = ci->len_alloc = from->len; ci->cursor = from->cursor; ci->type = from->type; } else { ci->line = MEM_callocN(64, "console-in-line"); ci->len_alloc = 64; ci->len = 0; } BLI_addtail(lb, ci); return ci; } static ConsoleLine *console_history_add(SpaceConsole *sc, ConsoleLine *from) { return console_lb_add__internal(&sc->history, from); } #if 0 /* may use later ? */ static ConsoleLine *console_scrollback_add(const bContext *C, ConsoleLine *from) { SpaceConsole *sc = CTX_wm_space_console(C); return console_lb_add__internal(&sc->scrollback, from); }
static ConsoleLine *console_history_add(const bContext *C, ConsoleLine *from) { SpaceConsole *sc= CTX_wm_space_console(C); return console_lb_add__internal(&sc->history, from); }
static int console_delete_exec(bContext *C, wmOperator *op) { SpaceConsole *sc = CTX_wm_space_console(C); ARegion *ar = CTX_wm_region(C); ConsoleLine *ci = console_history_verify(C); int pos; int stride; const short type = RNA_enum_get(op->ptr, "type"); bool done = false; if (ci->len == 0) { return OPERATOR_CANCELLED; } switch (type) { case DEL_NEXT_CHAR: case DEL_NEXT_WORD: if (ci->cursor < ci->len) { pos = ci->cursor; BLI_str_cursor_step_utf8(ci->line, ci->len, &pos, STRCUR_DIR_NEXT, (type == DEL_NEXT_CHAR) ? STRCUR_JUMP_NONE : STRCUR_JUMP_DELIM, true); stride = pos - ci->cursor; if (stride) { memmove(ci->line + ci->cursor, ci->line + ci->cursor + stride, (ci->len - (ci->cursor + stride)) + 1); ci->len -= stride; BLI_assert(ci->len >= 0); done = true; } } break; case DEL_PREV_CHAR: case DEL_PREV_WORD: if (ci->cursor > 0) { pos = ci->cursor; BLI_str_cursor_step_utf8(ci->line, ci->len, &pos, STRCUR_DIR_PREV, (type == DEL_PREV_CHAR) ? STRCUR_JUMP_NONE : STRCUR_JUMP_DELIM, true); stride = ci->cursor - pos; if (stride) { ci->cursor -= stride; /* same as above */ memmove(ci->line + ci->cursor, ci->line + ci->cursor + stride, (ci->len - (ci->cursor + stride)) + 1); ci->len -= stride; BLI_assert(ci->len >= 0); done = true; } } break; } if (!done) { return OPERATOR_CANCELLED; } else { console_select_offset(sc, -stride); } console_textview_update_rect(sc, ar); ED_area_tag_redraw(CTX_wm_area(C)); console_scroll_bottom(ar); return OPERATOR_FINISHED; }