// TODO, get this working again!
static int report_replay_exec(bContext *C, wmOperator *UNUSED(op))
{
// SpaceInfo *sc = CTX_wm_space_info(C);
// ReportList *reports = CTX_wm_reports(C);
// int report_mask = info_report_mask(sc);
// Report *report;
#if 0
sc->type = CONSOLE_TYPE_PYTHON;
for (report = reports->list.last; report; report = report->prev) {
if ((report->type & report_mask) &&
(report->type & RPT_OPERATOR_ALL | RPT_PROPERTY_ALL) &&
(report->flag & SELECT))
{
console_history_add_str(sc, report->message, 0);
WM_operator_name_call(C, "CONSOLE_OT_execute", WM_OP_EXEC_DEFAULT, NULL);
ED_area_tag_redraw(CTX_wm_area(C));
}
}
sc->type = CONSOLE_TYPE_REPORT;
#endif
ED_area_tag_redraw(CTX_wm_area(C));
return OPERATOR_FINISHED;
}
static int localview_exec(bContext *C, wmOperator *op)
{
Main *bmain = CTX_data_main(C);
Scene *scene = CTX_data_scene(C);
ScrArea *sa = CTX_wm_area(C);
View3D *v3d = CTX_wm_view3d(C);
bool change;
if (v3d->localvd) {
change = view3d_localview_exit(bmain, scene, sa);
}
else {
change = view3d_localview_init(bmain, scene, sa, op->reports);
}
if (change) {
DAG_id_type_tag(bmain, ID_OB);
ED_area_tag_redraw(CTX_wm_area(C));
return OPERATOR_FINISHED;
}
else {
return OPERATOR_CANCELLED;
}
}
static void rna_Area_type_update(bContext *C, PointerRNA *ptr)
{
wmWindowManager *wm = CTX_wm_manager(C);
wmWindow *win;
bScreen *sc = (bScreen *)ptr->id.data;
ScrArea *sa = (ScrArea *)ptr->data;
/* XXX this call still use context, so we trick it to work in the right context */
for (win = wm->windows.first; win; win = win->next) {
if (sc == win->screen) {
wmWindow *prevwin = CTX_wm_window(C);
ScrArea *prevsa = CTX_wm_area(C);
ARegion *prevar = CTX_wm_region(C);
CTX_wm_window_set(C, win);
CTX_wm_area_set(C, sa);
CTX_wm_region_set(C, NULL);
ED_area_newspace(C, sa, sa->butspacetype);
ED_area_tag_redraw(sa);
CTX_wm_window_set(C, prevwin);
CTX_wm_area_set(C, prevsa);
CTX_wm_region_set(C, prevar);
break;
}
}
}
static int actkeys_viewall(bContext *C, const short onlySel)
{
bAnimContext ac;
View2D *v2d;
float extra;
/* get editor data */
if (ANIM_animdata_get_context(C, &ac) == 0)
return OPERATOR_CANCELLED;
v2d= &ac.ar->v2d;
/* set the horizontal range, with an extra offset so that the extreme keys will be in view */
get_keyframe_extents(&ac, &v2d->cur.xmin, &v2d->cur.xmax, onlySel);
extra= 0.1f * (v2d->cur.xmax - v2d->cur.xmin);
v2d->cur.xmin -= extra;
v2d->cur.xmax += extra;
/* set vertical range */
v2d->cur.ymax= 0.0f;
v2d->cur.ymin= (float)-(v2d->mask.ymax - v2d->mask.ymin);
/* do View2D syncing */
UI_view2d_sync(CTX_wm_screen(C), CTX_wm_area(C), v2d, V2D_LOCK_COPY);
/* just redraw this view */
ED_area_tag_redraw(CTX_wm_area(C));
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 localview_exec(bContext *C, wmOperator *op)
{
const int smooth_viewtx = WM_operator_smooth_viewtx_get(op);
wmWindowManager *wm = CTX_wm_manager(C);
wmWindow *win = CTX_wm_window(C);
Main *bmain = CTX_data_main(C);
Scene *scene = CTX_data_scene(C);
ScrArea *sa = CTX_wm_area(C);
View3D *v3d = CTX_wm_view3d(C);
bool changed;
if (v3d->localvd) {
changed = view3d_localview_exit(wm, win, bmain, scene, sa, smooth_viewtx);
}
else {
changed = view3d_localview_init(wm, win, bmain, scene, sa, smooth_viewtx, op->reports);
}
if (changed) {
DAG_id_type_tag(bmain, ID_OB);
ED_area_tag_redraw(sa);
/* unselected objects become selected when exiting */
if (v3d->localvd == NULL) {
WM_event_add_notifier(C, NC_SCENE | ND_OB_SELECT, scene);
}
return OPERATOR_FINISHED;
}
else {
return OPERATOR_CANCELLED;
}
}
static void rna_Area_type_update(bContext *C, PointerRNA *ptr)
{
wmWindowManager *wm = CTX_wm_manager(C);
wmWindow *win;
bScreen *sc = (bScreen *)ptr->id.data;
ScrArea *sa = (ScrArea *)ptr->data;
/* XXX this call still use context, so we trick it to work in the right context */
for (win = wm->windows.first; win; win = win->next) {
if (sc == win->screen) {
wmWindow *prevwin = CTX_wm_window(C);
ScrArea *prevsa = CTX_wm_area(C);
ARegion *prevar = CTX_wm_region(C);
CTX_wm_window_set(C, win);
CTX_wm_area_set(C, sa);
CTX_wm_region_set(C, NULL);
ED_area_newspace(C, sa, sa->butspacetype, true);
ED_area_tag_redraw(sa);
/* It is possible that new layers becomes visible. */
if (sa->spacetype == SPACE_VIEW3D) {
DAG_on_visible_update(CTX_data_main(C), false);
}
CTX_wm_window_set(C, prevwin);
CTX_wm_area_set(C, prevsa);
CTX_wm_region_set(C, prevar);
break;
}
}
}
static int report_select_all_toggle_exec(bContext *C, wmOperator *UNUSED(op))
{
SpaceInfo *sinfo = CTX_wm_space_info(C);
ReportList *reports = CTX_wm_reports(C);
int report_mask = info_report_mask(sinfo);
int deselect = 0;
Report *report;
for (report = reports->list.last; report; report = report->prev) {
if ((report->type & report_mask) && (report->flag & SELECT)) {
deselect = 1;
break;
}
}
if (deselect) {
for (report = reports->list.last; report; report = report->prev)
if (report->type & report_mask)
report->flag &= ~SELECT;
}
else {
for (report = reports->list.last; report; report = report->prev)
if (report->type & report_mask)
report->flag |= SELECT;
}
ED_area_tag_redraw(CTX_wm_area(C));
return OPERATOR_FINISHED;
}
static int report_delete_exec(bContext *C, wmOperator *UNUSED(op))
{
SpaceInfo *sinfo = CTX_wm_space_info(C);
ReportList *reports = CTX_wm_reports(C);
int report_mask = info_report_mask(sinfo);
Report *report, *report_next;
for (report = reports->list.first; report; ) {
report_next = report->next;
if ((report->type & report_mask) && (report->flag & SELECT)) {
BLI_remlink(&reports->list, report);
MEM_freeN((void *)report->message);
MEM_freeN(report);
}
report = report_next;
}
ED_area_tag_redraw(CTX_wm_area(C));
return OPERATOR_FINISHED;
}
static int text_autocomplete_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
SpaceText *st = CTX_wm_space_text(C);
Text *text = CTX_data_edit_text(C);
st->doplugins = true;
op->customdata = text_autocomplete_build(text);
if (texttool_suggest_first()) {
ED_area_tag_redraw(CTX_wm_area(C));
if (texttool_suggest_first() == texttool_suggest_last()) {
confirm_suggestion(st->text);
text_update_line_edited(st->text->curl);
text_autocomplete_free(C, op);
return OPERATOR_FINISHED;
}
else {
WM_event_add_modal_handler(C, op);
return OPERATOR_RUNNING_MODAL;
}
}
else {
text_autocomplete_free(C, op);
return OPERATOR_CANCELLED;
}
}
static void template_texture_show(bContext *C, void *data_p, void *prop_p)
{
SpaceButs *sbuts = CTX_wm_space_buts(C);
ButsContextTexture *ct = (sbuts) ? sbuts->texuser : NULL;
ButsTextureUser *user;
if (!ct)
return;
for (user = ct->users.first; user; user = user->next)
if (user->ptr.data == data_p && user->prop == prop_p)
break;
if (user) {
/* select texture */
template_texture_select(C, user, NULL);
/* change context */
sbuts->mainb = BCONTEXT_TEXTURE;
sbuts->mainbuser = sbuts->mainb;
sbuts->preview = 1;
/* redraw editor */
ED_area_tag_redraw(CTX_wm_area(C));
}
}
static int file_select_all_exec(bContext *C, wmOperator *UNUSED(op))
{
ScrArea *sa = CTX_wm_area(C);
SpaceFile *sfile = CTX_wm_space_file(C);
FileSelection sel;
int numfiles = filelist_numfiles(sfile->files);
int i;
bool is_selected = false;
sel.first = 0;
sel.last = numfiles - 1;
/* Is any file selected ? */
for (i = 0; i < numfiles; ++i) {
if (filelist_is_selected(sfile->files, i, CHECK_ALL)) {
is_selected = true;
break;
}
}
/* select all only if previously no file was selected */
if (is_selected) {
filelist_select(sfile->files, &sel, FILE_SEL_REMOVE, SELECTED_FILE, CHECK_ALL);
}
else {
const FileCheckType check_type = (sfile->params->flag & FILE_DIRSEL_ONLY) ? CHECK_DIRS : CHECK_FILES;
filelist_select(sfile->files, &sel, FILE_SEL_ADD, SELECTED_FILE, check_type);
}
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_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;
}
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;
}
/* 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;
}
static int move_exec(bContext *C, wmOperator *op)
{
ConsoleLine *ci= console_history_verify(C);
int type= RNA_enum_get(op->ptr, "type");
int done= 0;
switch(type) {
case LINE_BEGIN:
done= console_line_cursor_set(ci, 0);
break;
case LINE_END:
done= console_line_cursor_set(ci, INT_MAX);
break;
case PREV_CHAR:
done= console_line_cursor_set(ci, ci->cursor-1);
break;
case NEXT_CHAR:
done= console_line_cursor_set(ci, ci->cursor+1);
break;
/* - if the character is a delimiter then skip delimiters (including white space)
* - when jump over the word */
case PREV_WORD:
while(text_check_delim(cursor_char_prev(ci)))
if(console_line_cursor_set(ci, ci->cursor-1)==FALSE)
break;
while(text_check_delim(cursor_char_prev(ci))==FALSE)
if(console_line_cursor_set(ci, ci->cursor-1)==FALSE)
break;
/* This isnt used for NEXT_WORD because when going back
* its more useful to have the cursor directly after a word then whitespace */
while(text_check_whitespace(cursor_char_prev(ci))==TRUE)
if(console_line_cursor_set(ci, ci->cursor-1)==FALSE)
break;
done= 1; /* assume changed */
break;
case NEXT_WORD:
while(text_check_delim(cursor_char(ci))==TRUE)
if (console_line_cursor_set(ci, ci->cursor+1)==FALSE)
break;
while(text_check_delim(cursor_char(ci))==FALSE)
if (console_line_cursor_set(ci, ci->cursor+1)==FALSE)
break;
done= 1; /* assume changed */
break;
}
if(done) {
ED_area_tag_redraw(CTX_wm_area(C));
}
return OPERATOR_FINISHED;
}
static void sample_exit(bContext *C, wmOperator *op)
{
ImageSampleInfo *info = op->customdata;
ED_region_draw_cb_exit(info->art, info->draw_handle);
ED_area_tag_redraw(CTX_wm_area(C));
MEM_freeN(info);
}
static void do_node_region_buttons(bContext *C, void *UNUSED(arg), int event)
{
//SpaceNode *snode= CTX_wm_space_node(C);
switch(event) {
case B_REDR:
ED_area_tag_redraw(CTX_wm_area(C));
return; /* no notifier! */
}
}
static int render_view_show_invoke(bContext *C, wmOperator *UNUSED(op), const wmEvent *event)
{
wmWindow *wincur = CTX_wm_window(C);
/* test if we have currently a temp screen active */
if (wincur->screen->temp) {
wm_window_lower(wincur);
}
else {
wmWindow *win, *winshow;
ScrArea *sa = find_area_showing_r_result(C, CTX_data_scene(C), &winshow);
/* is there another window on current scene showing result? */
for (win = CTX_wm_manager(C)->windows.first; win; win = win->next) {
bScreen *sc = win->screen;
if ((sc->temp && ((ScrArea *)sc->areabase.first)->spacetype == SPACE_IMAGE) ||
(win == winshow && winshow != wincur))
{
wm_window_raise(win);
return OPERATOR_FINISHED;
}
}
/* determine if render already shows */
if (sa) {
/* but don't close it when rendering */
if (G.is_rendering == false) {
SpaceImage *sima = sa->spacedata.first;
if (sima->flag & SI_PREVSPACE) {
sima->flag &= ~SI_PREVSPACE;
if (sima->flag & SI_FULLWINDOW) {
sima->flag &= ~SI_FULLWINDOW;
ED_screen_full_prevspace(C, sa, false);
}
else if (sima->next) {
/* workaround for case of double prevspace, render window
* with a file browser on top of it (same as in ED_area_prevspace) */
if (sima->next->spacetype == SPACE_FILE && sima->next->next)
ED_area_newspace(C, sa, sima->next->next->spacetype);
else
ED_area_newspace(C, sa, sima->next->spacetype);
ED_area_tag_redraw(sa);
}
}
}
}
else {
render_view_open(C, event->x, event->y);
}
}
return OPERATOR_FINISHED;
}
static int actkeys_viewall(bContext *C, const bool only_sel)
{
bAnimContext ac;
View2D *v2d;
float extra, min, max;
bool found;
/* get editor data */
if (ANIM_animdata_get_context(C, &ac) == 0)
return OPERATOR_CANCELLED;
v2d = &ac.ar->v2d;
/* set the horizontal range, with an extra offset so that the extreme keys will be in view */
found = get_keyframe_extents(&ac, &min, &max, only_sel);
if (only_sel && (found == false))
return OPERATOR_CANCELLED;
v2d->cur.xmin = min;
v2d->cur.xmax = max;
extra = 0.1f * BLI_rctf_size_x(&v2d->cur);
v2d->cur.xmin -= extra;
v2d->cur.xmax += extra;
/* set vertical range */
if (only_sel == false) {
/* view all -> the summary channel is usually the shows everything, and resides right at the top... */
v2d->cur.ymax = 0.0f;
v2d->cur.ymin = (float)-BLI_rcti_size_y(&v2d->mask);
}
else {
/* locate first selected channel (or the active one), and frame those */
float ymin = v2d->cur.ymin;
float ymax = v2d->cur.ymax;
if (actkeys_channels_get_selected_extents(&ac, &ymin, &ymax)) {
/* recenter the view so that this range is in the middle */
float ymid = (ymax - ymin) / 2.0f + ymin;
float x_center;
UI_view2d_center_get(v2d, &x_center, NULL);
UI_view2d_center_set(v2d, x_center, ymid);
}
}
/* do View2D syncing */
UI_view2d_sync(CTX_wm_screen(C), CTX_wm_area(C), v2d, V2D_LOCK_COPY);
/* just redraw this view */
ED_area_tag_redraw(CTX_wm_area(C));
return OPERATOR_FINISHED;
}
static void pin_cb(bContext *C, void *UNUSED(arg1), void *UNUSED(arg2))
{
SpaceButs *sbuts = CTX_wm_space_buts(C);
if (sbuts->flag & SB_PIN_CONTEXT) {
sbuts->pinid = buttons_context_id_path(C);
}
else
sbuts->pinid = NULL;
ED_area_tag_redraw(CTX_wm_area(C));
}
static int file_highlight_invoke(bContext *C, wmOperator *UNUSED(op), const wmEvent *event)
{
ARegion *ar = CTX_wm_region(C);
SpaceFile *sfile = CTX_wm_space_file(C);
if (!file_highlight_set(sfile, ar, event->x, event->y))
return OPERATOR_CANCELLED;
ED_area_tag_redraw(CTX_wm_area(C));
return OPERATOR_FINISHED;
}
static int localview_exec(bContext *C, wmOperator *UNUSED(unused))
{
View3D *v3d= CTX_wm_view3d(C);
if(v3d->localvd)
endlocalview(CTX_data_main(C), CTX_data_scene(C), CTX_wm_area(C));
else
initlocalview(CTX_data_main(C), CTX_data_scene(C), CTX_wm_area(C));
ED_area_tag_redraw(CTX_wm_area(C));
return OPERATOR_FINISHED;
}
static int select_report_pick_exec(bContext *C, wmOperator *op)
{
int report_index = RNA_int_get(op->ptr, "report_index");
Report *report = BLI_findlink(&CTX_wm_reports(C)->list, report_index);
if (!report)
return OPERATOR_CANCELLED;
report->flag ^= SELECT; /* toggle */
ED_area_tag_redraw(CTX_wm_area(C));
return OPERATOR_FINISHED;
}
static void do_action_buttons(bContext *C, void *arg, int event)
{
/* special exception for mode changing - enable custom settings? */
if (event == B_MODECHANGE) {
SpaceAction *saction= CTX_wm_space_action(C);
/* if the new mode is ShapeKeys editor, enable sliders */
if (saction->mode == SACTCONT_SHAPEKEY)
saction->flag |= SACTION_SLIDERS;
}
ED_area_tag_refresh(CTX_wm_area(C));
ED_area_tag_redraw(CTX_wm_area(C));
}
static int toggle_time_exec(bContext *C, wmOperator *UNUSED(op))
{
ScrArea *curarea= CTX_wm_area(C);
if (curarea == NULL)
return OPERATOR_CANCELLED;
/* simply toggle draw frames flag in applicable spaces */
// XXX or should relevant spaces define their own version of this?
switch (curarea->spacetype) {
case SPACE_TIME: /* TimeLine */
{
SpaceTime *stime= CTX_wm_space_time(C);
stime->flag ^= TIME_DRAWFRAMES;
}
break;
case SPACE_ACTION: /* Action Editor */
{
SpaceAction *saction= CTX_wm_space_action(C);
saction->flag ^= SACTION_DRAWTIME;
}
break;
case SPACE_IPO: /* Graph Editor */
{
SpaceIpo *sipo= CTX_wm_space_graph(C);
sipo->flag ^= SIPO_DRAWTIME;
}
break;
case SPACE_NLA: /* NLA Editor */
{
SpaceNla *snla= CTX_wm_space_nla(C);
snla->flag ^= SNLA_DRAWTIME;
}
break;
case SPACE_SEQ: /* Sequencer */
{
SpaceSeq *sseq= CTX_wm_space_seq(C);
sseq->flag ^= SEQ_DRAWFRAMES;
}
break;
default: /* editor doesn't show frames */
return OPERATOR_CANCELLED; // XXX or should we pass through instead?
}
ED_area_tag_redraw(curarea);
return OPERATOR_FINISHED;
}
static int reset_recent_exec(bContext *C, wmOperator *UNUSED(op))
{
ScrArea *sa = CTX_wm_area(C);
char name[FILE_MAX];
struct FSMenu *fsmenu = fsmenu_get();
while (fsmenu_get_entry(fsmenu, FS_CATEGORY_RECENT, 0) != NULL) {
fsmenu_remove_entry(fsmenu, FS_CATEGORY_RECENT, 0);
}
BLI_make_file_string("/", name, BLI_get_folder_create(BLENDER_USER_CONFIG, NULL), BLENDER_BOOKMARK_FILE);
fsmenu_write_file(fsmenu, name);
ED_area_tag_redraw(sa);
return OPERATOR_FINISHED;
}
/* 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 file_filenum_exec(bContext *C, wmOperator *op)
{
SpaceFile *sfile= CTX_wm_space_file(C);
ScrArea *sa= CTX_wm_area(C);
int inc = RNA_int_get(op->ptr, "increment");
if(sfile->params && (inc != 0)) {
BLI_newname(sfile->params->file, inc);
ED_area_tag_redraw(sa);
file_draw_check_cb(C, NULL, NULL);
// WM_event_add_notifier(C, NC_WINDOW, NULL);
}
return OPERATOR_FINISHED;
}
