Example #1
0
/* the python exec operator uses this */
static int 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 prevernts crashes when no command line */
	short 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(strcmp(ci->line, ci_prev->line)==0)
			console_history_free(sc, ci_prev);
	}

	if(reverse) { /* last item in mistory */
		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(C, (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));

	return OPERATOR_FINISHED;
}
Example #2
0
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;
}
Example #3
0
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;
}
Example #4
0
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(sc, ci);
	console_history_add(sc, NULL);
	console_select_offset(sc, -ci->len);

	console_textview_update_rect(sc, ar);

	ED_area_tag_redraw(CTX_wm_area(C));

	console_scroll_bottom(ar);

	return OPERATOR_FINISHED;
}
Example #5
0
/* 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;
}
Example #6
0
static int console_unindent_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;
	}

	if (spaces == 0)
		return OPERATOR_CANCELLED;

	len = spaces % TAB_LENGTH;
	if (len == 0)
		len = TAB_LENGTH;

	console_line_verify_length(ci, ci->len - len);

	memmove(ci->line, ci->line + len, (ci->len - len) + 1);
	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;
}
Example #7
0
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;
}
Example #8
0
ConsoleLine *console_scrollback_add_str(SpaceConsole *sc, char *str, bool own)
{
	ConsoleLine *ci = console_lb_add_str__internal(&sc->scrollback, str, own);
	console_select_offset(sc, ci->len + 1);
	return ci;
}