bartvdbraak/blender
1
0
Fork 4
Code Issues 4 Pull Requests 1 Actions 1 Packages Projects Releases Wiki Activity

Text Editor: remove text marker functionality. Patch [#33251]

Browse Source
This commit is contained in:
Justin Dailey 2012-11-23 14:33:14 +00:00
parent c25cfd3044
commit c407c951a0
13 changed files with 40 additions and 907 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
release/scripts/startup/bl_ui/space_text.py
View File

@ -137,9 +137,6 @@ class TEXT_PT_find(Panel):
row.operator("text.replace_set_selected", text="", icon='TEXT')
col.operator("text.replace")
# mark
layout.operator("text.mark_all")
# settings
layout.prop(st, "use_match_case")
row = layout.row()
@ -216,17 +213,6 @@ class TEXT_MT_edit_select(Menu):
layout.operator("text.select_line")
class TEXT_MT_edit_markers(Menu):
bl_label = "Markers"
def draw(self, context):
layout = self.layout
layout.operator("text.markers_clear")
layout.operator("text.next_marker")
layout.operator("text.previous_marker")
class TEXT_MT_format(Menu):
bl_label = "Format"
@ -290,7 +276,6 @@ class TEXT_MT_edit(Menu):
layout.separator()
layout.menu("TEXT_MT_edit_select")
layout.menu("TEXT_MT_edit_markers")
layout.separator()

12
source/blender/blenkernel/BKE_text.h
View File

@ -100,14 +100,6 @@ void txt_move_lines (struct Text *text, const int direction);
void txt_duplicate_line (struct Text *text);
int setcurr_tab_spaces (struct Text *text, int space);
void txt_add_marker (struct Text *text, struct TextLine *line, int start, int end, const unsigned char color[4], int group, int flags);
short txt_clear_marker_region (struct Text *text, struct TextLine *line, int start, int end, int group, int flags);
short txt_clear_markers (struct Text *text, int group, int flags);
struct TextMarker *txt_find_marker (struct Text *text, struct TextLine *line, int curs, int group, int flags);
struct TextMarker *txt_find_marker_region (struct Text *text, struct TextLine *line, int start, int end, int group, int flags);
struct TextMarker *txt_prev_marker (struct Text *text, struct TextMarker *marker);
struct TextMarker *txt_next_marker (struct Text *text, struct TextMarker *marker);
/* utility functions, could be moved somewhere more generic but are python/text related */
int text_check_bracket(const char ch);
int text_check_delim(const char ch);
@ -161,10 +153,6 @@ enum {
#define UNDO_DUPLICATE 040
/* Marker flags */
#define TMARK_TEMP 0x01 /* Remove on non-editing events, don't save */
#define TMARK_EDITALL 0x02 /* Edit all markers of the same group as one */
#ifdef __cplusplus
}
#endif

321
source/blender/blenkernel/intern/text.c
View File

@ -96,17 +96,6 @@
* If the user moves the cursor the st containing that cursor should
* be popped ... other st's retain their own top location.
*
* Markers
* --
* The mrk->flags define the behavior and relationships between markers. The
* upper two bytes are used to hold a group ID, the lower two are normal flags. If
* TMARK_EDITALL is set the group ID defines which other markers should be edited.
*
* The mrk->clr field is used to visually group markers where the flags may not
* match. A template system, for example, may allow editing of repeating tokens
* (in one group) but include other marked positions (in another group) all in the
* same template with the same color.
*
* Undo
* --
* Undo/Redo works by storing
@ -174,7 +163,6 @@ void BKE_text_free(Text *text)
}
BLI_freelistN(&text->lines);
BLI_freelistN(&text->markers);
if (text->name) MEM_freeN(text->name);
MEM_freeN(text->undo_buf);
@ -202,7 +190,6 @@ Text *BKE_text_add(const char *name)
ta->flags |= TXT_TABSTOSPACES;
ta->lines.first = ta->lines.last = NULL;
ta->markers.first = ta->markers.last = NULL;
tmp = (TextLine *) MEM_mallocN(sizeof(TextLine), "textline");
tmp->line = (char *) MEM_mallocN(1, "textline_string");
@ -398,7 +385,6 @@ Text *BKE_text_load(const char *file, const char *relpath)
ta->id.us = 1;
ta->lines.first = ta->lines.last = NULL;
ta->markers.first = ta->markers.last = NULL;
ta->curl = ta->sell = NULL;
if ((U.flag & USER_TXT_TABSTOSPACES_DISABLE) == 0)
@ -495,7 +481,6 @@ Text *BKE_text_copy(Text *ta)
tan->flags = ta->flags | TXT_ISDIRTY;
tan->lines.first = tan->lines.last = NULL;
tan->markers.first = tan->markers.last = NULL;
tan->curl = tan->sell = NULL;
tan->nlines = ta->nlines;
@ -1150,9 +1135,7 @@ int txt_has_sel(Text *text)
static void txt_delete_sel(Text *text)
{
TextLine *tmpl;
TextMarker *mrk;
char *buf;
int move, lineno;
if (!text) return;
if (!text->curl) return;
@ -1169,28 +1152,6 @@ static void txt_delete_sel(Text *text)
}
buf = MEM_mallocN(text->curc + (text->sell->len - text->selc) + 1, "textline_string");
if (text->curl != text->sell) {
txt_clear_marker_region(text, text->curl, text->curc, text->curl->len, 0, 0);
move = txt_get_span(text->curl, text->sell);
}
else {
mrk = txt_find_marker_region(text, text->curl, text->curc, text->selc, 0, 0);
if (mrk && (mrk->start > text->curc || mrk->end < text->selc))
txt_clear_marker_region(text, text->curl, text->curc, text->selc, 0, 0);
move = 0;
}
mrk = txt_find_marker_region(text, text->sell, text->selc - 1, text->sell->len, 0, 0);
if (mrk) {
lineno = mrk->lineno;
do {
mrk->lineno -= move;
if (mrk->start > text->curc) mrk->start -= text->selc - text->curc;
mrk->end -= text->selc - text->curc;
mrk = mrk->next;
} while (mrk && mrk->lineno == lineno);
}
strncpy(buf, text->curl->line, text->curc);
strcpy(buf + text->curc, text->sell->line + text->selc);
@ -1419,19 +1380,9 @@ char *txt_sel_to_buf(Text *text)
return buf;
}
static void txt_shift_markers(Text *text, int lineno, int count)
{
TextMarker *marker;
for (marker = text->markers.first; marker; marker = marker->next)
if (marker->lineno >= lineno) {
marker->lineno += count;
}
}
void txt_insert_buf(Text *text, const char *in_buffer)
{
int l = 0, u, len, lineno = -1, count = 0;
int l = 0, u, len;
size_t i = 0, j;
TextLine *add;
char *buffer;
@ -1458,9 +1409,6 @@ void txt_insert_buf(Text *text, const char *in_buffer)
else { undoing = u; MEM_freeN(buffer); return; }
i++;
/* Read as many full lines as we can */
lineno = txt_get_span(text->lines.first, text->curl);
while (i < len) {
l = 0;
@ -1472,14 +1420,8 @@ void txt_insert_buf(Text *text, const char *in_buffer)
add = txt_new_linen(buffer + (i - l), l);
BLI_insertlinkbefore(&text->lines, text->curl, add);
i++;
count++;
}
else {
if (count) {
txt_shift_markers(text, lineno, count);
count = 0;
}
for (j = i - l; j < i && j < len; )
txt_add_raw_char(text, BLI_str_utf8_as_unicode_step(buffer, &j));
break;
@ -1488,10 +1430,6 @@ void txt_insert_buf(Text *text, const char *in_buffer)
MEM_freeN(buffer);
if (count) {
txt_shift_markers(text, lineno, count);
}
undoing = u;
}
@ -2324,31 +2262,13 @@ void txt_do_redo(Text *text)
void txt_split_curline(Text *text)
{
TextLine *ins;
TextMarker *mrk;
char *left, *right;
int lineno = -1;
if (!text) return;
if (!text->curl) return;
txt_delete_sel(text);
/* Move markers */
lineno = txt_get_span(text->lines.first, text->curl);
mrk = text->markers.first;
while (mrk) {
if (mrk->lineno == lineno && mrk->start > text->curc) {
mrk->lineno++;
mrk->start -= text->curc;
mrk->end -= text->curc;
}
else if (mrk->lineno > lineno) {
mrk->lineno++;
}
mrk = mrk->next;
}
/* Make the two half strings */
left = MEM_mallocN(text->curc + 1, "textline_string");
@ -2385,25 +2305,9 @@ void txt_split_curline(Text *text)
static void txt_delete_line(Text *text, TextLine *line)
{
TextMarker *mrk = NULL, *nxt;
if (!text) return;
if (!text->curl) return;
/* warning, this can be _slow_ when deleting many lines! */
if ((mrk = text->markers.first)) {
int lineno = txt_get_span(text->lines.first, line);
mrk = text->markers.first;
while (mrk) {
nxt = mrk->next;
if (mrk->lineno == lineno)
BLI_freelinkN(&text->markers, mrk);
else if (mrk->lineno > lineno)
mrk->lineno--;
mrk = nxt;
}
}
BLI_remlink(&text->lines, line);
if (line->line) MEM_freeN(line->line);
@ -2418,27 +2322,11 @@ static void txt_delete_line(Text *text, TextLine *line)
static void txt_combine_lines(Text *text, TextLine *linea, TextLine *lineb)
{
char *tmp;
TextMarker *mrk = NULL;
if (!text) return;
if (!linea || !lineb) return;
mrk = txt_find_marker_region(text, lineb, 0, lineb->len, 0, 0);
if (mrk) {
int lineno;
lineno = mrk->lineno;
do {
mrk->lineno--;
mrk->start += linea->len;
mrk->end += linea->len;
mrk = mrk->next;
} while (mrk && mrk->lineno == lineno);
}
#if 0 /* UNUSED */
if (lineno == -1)
lineno = txt_get_span(text->lines.first, lineb);
#endif
tmp = MEM_mallocN(linea->len + lineb->len + 1, "textline_string");
@ -2492,27 +2380,7 @@ void txt_delete_char(Text *text)
}
else { /* Just deleting a char */
size_t c_len = 0;
TextMarker *mrk;
c = BLI_str_utf8_as_unicode_and_size(text->curl->line + text->curc, &c_len);
mrk = txt_find_marker_region(text, text->curl, text->curc - c_len, text->curl->len, 0, 0);
if (mrk) {
int lineno = mrk->lineno;
if (mrk->end == text->curc) {
if ((mrk->flags & TMARK_TEMP) && !(mrk->flags & TMARK_EDITALL)) {
txt_clear_markers(text, mrk->group, TMARK_TEMP);
}
else {
BLI_freelinkN(&text->markers, mrk);
}
return;
}
do {
if (mrk->start > text->curc) mrk->start -= c_len;
mrk->end -= c_len;
mrk = mrk->next;
} while (mrk && mrk->lineno == lineno);
}
memmove(text->curl->line + text->curc, text->curl->line + text->curc + c_len, text->curl->len - text->curc - c_len + 1);
@ -2556,28 +2424,8 @@ void txt_backspace_char(Text *text)
}
else { /* Just backspacing a char */
size_t c_len = 0;
TextMarker *mrk;
char *prev = BLI_str_prev_char_utf8(text->curl->line + text->curc);
c = BLI_str_utf8_as_unicode_and_size(prev, &c_len);
mrk = txt_find_marker_region(text, text->curl, text->curc - c_len, text->curl->len, 0, 0);
if (mrk) {
int lineno = mrk->lineno;
if (mrk->start == text->curc) {
if ((mrk->flags & TMARK_TEMP) && !(mrk->flags & TMARK_EDITALL)) {
txt_clear_markers(text, mrk->group, TMARK_TEMP);
}
else {
BLI_freelinkN(&text->markers, mrk);
}
return;
}
do {
if (mrk->start > text->curc - c_len) mrk->start -= c_len;
mrk->end -= c_len;
mrk = mrk->next;
} while (mrk && mrk->lineno == lineno);
}
/* source and destination overlap, don't use memcpy() */
memmove(text->curl->line + text->curc - c_len,
@ -2619,9 +2467,7 @@ static void txt_convert_tab_to_spaces(Text *text)
static int txt_add_char_intern(Text *text, unsigned int add, int replace_tabs)
{
int lineno;
char *tmp, ch[BLI_UTF8_MAX];
TextMarker *mrk;
size_t add_len;
if (!text) return 0;
@ -2643,15 +2489,6 @@ static int txt_add_char_intern(Text *text, unsigned int add, int replace_tabs)
if (!undoing) txt_undo_add_charop(text, UNDO_INSERT_1, add);
add_len = BLI_str_utf8_from_unicode(add, ch);
mrk = txt_find_marker_region(text, text->curl, text->curc - 1, text->curl->len, 0, 0);
if (mrk) {
lineno = mrk->lineno;
do {
if (mrk->start > text->curc) mrk->start += add_len;
mrk->end += add_len;
mrk = mrk->next;
} while (mrk && mrk->lineno == lineno);
}
tmp = MEM_mallocN(text->curl->len + add_len + 1, "textline_string");
@ -2698,10 +2535,7 @@ int txt_replace_char(Text *text, unsigned int add)
/* If text is selected or we're at the end of the line just use txt_add_char */
if (text->curc == text->curl->len || txt_has_sel(text) || add == '\n') {
int i = txt_add_char(text, add);
TextMarker *mrk = txt_find_marker(text, text->curl, text->curc, 0, 0);
if (mrk) BLI_freelinkN(&text->markers, mrk);
return i;
return txt_add_char(text, add);
}
del = BLI_str_utf8_as_unicode_and_size(text->curl->line + text->curc, &del_size);
@ -3039,157 +2873,6 @@ int setcurr_tab_spaces(Text *text, int space)
return i;
}
/*********************************/
/* Text marker utility functions */
/*********************************/
/* Creates and adds a marker to the list maintaining sorted order */
void txt_add_marker(Text *text, TextLine *line, int start, int end, const unsigned char color[4], int group, int flags)
{
TextMarker *tmp, *marker;
marker = MEM_mallocN(sizeof(TextMarker), "text_marker");
marker->lineno = txt_get_span(text->lines.first, line);
marker->start = MIN2(start, end);
marker->end = MAX2(start, end);
marker->group = group;
marker->flags = flags;
marker->color[0] = color[0];
marker->color[1] = color[1];
marker->color[2] = color[2];
marker->color[3] = color[3];
for (tmp = text->markers.last; tmp; tmp = tmp->prev)
if (tmp->lineno < marker->lineno || (tmp->lineno == marker->lineno && tmp->start < marker->start))
break;
if (tmp) BLI_insertlinkafter(&text->markers, tmp, marker);
else BLI_addhead(&text->markers, marker);
}
/* Returns the first matching marker on the specified line between two points.
* If the group or flags fields are non-zero the returned flag must be in the
* specified group and have at least the specified flags set. */
TextMarker *txt_find_marker_region(Text *text, TextLine *line, int start, int end, int group, int flags)
{
TextMarker *marker, *next;
int lineno = txt_get_span(text->lines.first, line);
for (marker = text->markers.first; marker; marker = next) {
next = marker->next;
if (group && marker->group != group) continue;
else if ((marker->flags & flags) != flags) continue;
else if (marker->lineno < lineno) continue;
else if (marker->lineno > lineno) break;
if ((marker->start == marker->end && start <= marker->start && marker->start <= end) ||
(marker->start < end && marker->end > start))
{
return marker;
}
}
return NULL;
}
/* Clears all markers on the specified line between two points. If the group or
* flags fields are non-zero the returned flag must be in the specified group
* and have at least the specified flags set. */
short txt_clear_marker_region(Text *text, TextLine *line, int start, int end, int group, int flags)
{
TextMarker *marker, *next;
int lineno = txt_get_span(text->lines.first, line);
short cleared = 0;
for (marker = text->markers.first; marker; marker = next) {
next = marker->next;
if (group && marker->group != group) continue;
else if ((marker->flags & flags) != flags) continue;
else if (marker->lineno < lineno) continue;
else if (marker->lineno > lineno) break;
if ((marker->start == marker->end && start <= marker->start && marker->start <= end) ||
(marker->start < end && marker->end > start))
{
BLI_freelinkN(&text->markers, marker);
cleared = 1;
}
}
return cleared;
}
/* Clears all markers in the specified group (if given) with at least the
* specified flags set. Useful for clearing temporary markers (group = 0,
* flags = TMARK_TEMP) */
short txt_clear_markers(Text *text, int group, int flags)
{
TextMarker *marker, *next;
short cleared = 0;
for (marker = text->markers.first; marker; marker = next) {
next = marker->next;
if ((!group || marker->group == group) &&
(marker->flags & flags) == flags)
{
BLI_freelinkN(&text->markers, marker);
cleared = 1;
}
}
return cleared;
}
/* Finds the marker at the specified line and cursor position with at least the
* specified flags set in the given group (if non-zero). */
TextMarker *txt_find_marker(Text *text, TextLine *line, int curs, int group, int flags)
{
TextMarker *marker;
int lineno = txt_get_span(text->lines.first, line);
for (marker = text->markers.first; marker; marker = marker->next) {
if (group && marker->group != group) continue;
else if ((marker->flags & flags) != flags) continue;
else if (marker->lineno < lineno) continue;
else if (marker->lineno > lineno) break;
if (marker->start <= curs && curs <= marker->end)
return marker;
}
return NULL;
}
/* Finds the previous marker in the same group. If no other is found, the same
* marker will be returned */
TextMarker *txt_prev_marker(Text *text, TextMarker *marker)
{
TextMarker *tmp = marker;
while (tmp) {
if (tmp->prev) tmp = tmp->prev;
else tmp = text->markers.last;
if (tmp->group == marker->group)
return tmp;
}
return NULL; /* Only if (marker == NULL) */
}
/* Finds the next marker in the same group. If no other is found, the same
* marker will be returned */
TextMarker *txt_next_marker(Text *text, TextMarker *marker)
{
TextMarker *tmp = marker;
while (tmp) {
if (tmp->next) tmp = tmp->next;
else tmp = text->markers.first;
if (tmp->group == marker->group)
return tmp;
}
return NULL; /* Only if (marker == NULL) */
}
/*******************************/
/* Character utility functions */
/*******************************/

1
source/blender/blenloader/intern/readfile.c
View File

@ -2983,7 +2983,6 @@ static void direct_link_text(FileData *fd, Text *text)
#endif
link_list(fd, &text->lines);
link_list(fd, &text->markers);
text->curl = newdataadr(fd, text->curl);
text->sell = newdataadr(fd, text->sell);

8
source/blender/blenloader/intern/writefile.c
View File

@ -2607,7 +2607,6 @@ static void write_texts(WriteData *wd, ListBase *idbase)
{
Text *text;
TextLine *tmp;
TextMarker *mrk;
text= idbase->first;
while (text) {
@ -2631,13 +2630,6 @@ static void write_texts(WriteData *wd, ListBase *idbase)
writedata(wd, DATA, tmp->len+1, tmp->line);
tmp= tmp->next;
}
/* write markers */
mrk= text->markers.first;
while (mrk) {
writestruct(wd, DATA, "TextMarker", 1, mrk);
mrk= mrk->next;
}
}

5
source/blender/editors/space_text/space_text.c
View File

@ -196,10 +196,6 @@ static void text_operatortypes(void)
WM_operatortype_append(TEXT_OT_unindent);
WM_operatortype_append(TEXT_OT_indent);
WM_operatortype_append(TEXT_OT_markers_clear);
WM_operatortype_append(TEXT_OT_next_marker);
WM_operatortype_append(TEXT_OT_previous_marker);
WM_operatortype_append(TEXT_OT_select_line);
WM_operatortype_append(TEXT_OT_select_all);
WM_operatortype_append(TEXT_OT_select_word);
@ -227,7 +223,6 @@ static void text_operatortypes(void)
WM_operatortype_append(TEXT_OT_find_set_selected);
WM_operatortype_append(TEXT_OT_replace);
WM_operatortype_append(TEXT_OT_replace_set_selected);
WM_operatortype_append(TEXT_OT_mark_all);
WM_operatortype_append(TEXT_OT_to_3d_object);

119
source/blender/editors/space_text/text_draw.c
View File

@ -1070,40 +1070,6 @@ int text_get_total_lines(SpaceText *st, ARegion *ar)
return drawcache->total_lines;
}
/* Move pointer to first visible line (top) */
static TextLine *first_visible_line(SpaceText *st, ARegion *ar, int *wrap_top)
{
Text *text = st->text;
TextLine *pline = text->lines.first;
int i = st->top, lineno = 0;
text_update_drawcache(st, ar);
if (wrap_top) *wrap_top = 0;
if (st->wordwrap) {
while (i > 0 && pline) {
int lines = text_get_visible_lines_no(st, lineno);
if (i - lines < 0) {
if (wrap_top) *wrap_top = i;
break;
}
else {
pline = pline->next;
i -= lines;
lineno++;
}
}
}
else {
for (i = st->top; pline->next && i > 0; i--)
pline = pline->next;
}
return pline;
}
/************************ draw scrollbar *****************************/
static void calc_text_rcts(SpaceText *st, ARegion *ar, rcti *scroll, rcti *back)
@ -1241,90 +1207,6 @@ static void draw_textscroll(SpaceText *st, rcti *scroll, rcti *back)
glDisable(GL_BLEND);
}
/************************** draw markers **************************/
static void draw_markers(SpaceText *st, ARegion *ar)
{
Text *text = st->text;
TextMarker *marker, *next;
TextLine *top, *line;
int offl, offc, i, x1, x2, y1, y2, x, y;
int topi, topy;
/* Move pointer to first visible line (top) */
top = first_visible_line(st, ar, NULL);
topi = BLI_findindex(&text->lines, top);
topy = txt_get_span(text->lines.first, top);
for (marker = text->markers.first; marker; marker = next) {
next = marker->next;
/* invisible line (before top) */
if (marker->lineno < topi) continue;
line = BLI_findlink(&text->lines, marker->lineno);
/* Remove broken markers */
if (marker->end > line->len || marker->start > marker->end) {
BLI_freelinkN(&text->markers, marker);
continue;
}
wrap_offset(st, ar, line, marker->start, &offl, &offc);
y1 = txt_get_span(top, line) - st->top + offl + topy;
x1 = text_get_char_pos(st, line->line, marker->start) - st->left + offc;
wrap_offset(st, ar, line, marker->end, &offl, &offc);
y2 = txt_get_span(top, line) - st->top + offl + topy;
x2 = text_get_char_pos(st, line->line, marker->end) - st->left + offc;
/* invisible part of line (before top, after last visible line) */
if (y2 < 0 || y1 > st->top + st->viewlines) continue;
glColor3ubv(marker->color);
x = st->showlinenrs ? TXT_OFFSET + TEXTXLOC : TXT_OFFSET;
y = ar->winy - 3;
if (y1 == y2) {
y -= y1 * st->lheight;
glBegin(GL_LINE_LOOP);
glVertex2i(x + x2 * st->cwidth + 1, y);
glVertex2i(x + x1 * st->cwidth - 2, y);
glVertex2i(x + x1 * st->cwidth - 2, y - st->lheight);
glVertex2i(x + x2 * st->cwidth + 1, y - st->lheight);
glEnd();
}
else {
y -= y1 * st->lheight;
glBegin(GL_LINE_STRIP);
glVertex2i(ar->winx, y);
glVertex2i(x + x1 * st->cwidth - 2, y);
glVertex2i(x + x1 * st->cwidth - 2, y - st->lheight);
glVertex2i(ar->winx, y - st->lheight);
glEnd();
y -= st->lheight;
for (i = y1 + 1; i < y2; i++) {
glBegin(GL_LINES);
glVertex2i(x, y);
glVertex2i(ar->winx, y);
glVertex2i(x, y - st->lheight);
glVertex2i(ar->winx, y - st->lheight);
glEnd();
y -= st->lheight;
}
glBegin(GL_LINE_STRIP);
glVertex2i(x, y);
glVertex2i(x + x2 * st->cwidth + 1, y);
glVertex2i(x + x2 * st->cwidth + 1, y - st->lheight);
glVertex2i(x, y - st->lheight);
glEnd();
}
}
}
/*********************** draw documentation *******************************/
static void draw_documentation(SpaceText *st, ARegion *ar)
@ -1860,7 +1742,6 @@ void draw_text_main(SpaceText *st, ARegion *ar)
/* draw other stuff */
draw_brackets(st, ar);
draw_markers(st, ar);
glTranslatef(GLA_PIXEL_OFS, GLA_PIXEL_OFS, 0.0f); /* XXX scroll requires exact pixel space */
draw_textscroll(st, &scroll, &back);
draw_documentation(st, ar);

8
source/blender/editors/space_text/text_intern.h
View File

@ -69,9 +69,6 @@ void text_update_cursor_moved(struct bContext *C);
#define TOOL_SUGG_LIST 0x01
#define TOOL_DOCUMENT 0x02
#define TMARK_GRP_CUSTOM 0x00010000 /* Lower 2 bytes used for Python groups */
#define TMARK_GRP_FINDALL 0x00020000
typedef struct FlattenString {
char fixedbuf[256];
int fixedaccum[256];
@ -130,10 +127,6 @@ void TEXT_OT_indent(struct wmOperatorType *ot);
void TEXT_OT_line_break(struct wmOperatorType *ot);
void TEXT_OT_insert(struct wmOperatorType *ot);
void TEXT_OT_markers_clear(struct wmOperatorType *ot);
void TEXT_OT_next_marker(struct wmOperatorType *ot);
void TEXT_OT_previous_marker(struct wmOperatorType *ot);
void TEXT_OT_select_line(struct wmOperatorType *ot);
void TEXT_OT_select_all(struct wmOperatorType *ot);
void TEXT_OT_select_word(struct wmOperatorType *ot);
@ -158,7 +151,6 @@ void TEXT_OT_find(struct wmOperatorType *ot);
void TEXT_OT_find_set_selected(struct wmOperatorType *ot);
void TEXT_OT_replace(struct wmOperatorType *ot);
void TEXT_OT_replace_set_selected(struct wmOperatorType *ot);
void TEXT_OT_mark_all(struct wmOperatorType *ot);
void TEXT_OT_to_3d_object(struct wmOperatorType *ot);

225
source/blender/editors/space_text/text_ops.c
View File

@ -1377,104 +1377,6 @@ void TEXT_OT_move_lines(wmOperatorType *ot)
RNA_def_enum(ot->srna, "direction", direction_items, 1, "Direction", "");
}
/******************* previous marker operator *********************/
static int text_previous_marker_exec(bContext *C, wmOperator *UNUSED(op))
{
Text *text = CTX_data_edit_text(C);
TextMarker *mrk;
int lineno;
lineno = txt_get_span(text->lines.first, text->curl);
mrk = text->markers.last;
while (mrk && (mrk->lineno > lineno || (mrk->lineno == lineno && mrk->end > text->curc)))
mrk = mrk->prev;
if (!mrk) mrk = text->markers.last;
if (mrk) {
txt_move_to(text, mrk->lineno, mrk->start, 0);
txt_move_to(text, mrk->lineno, mrk->end, 1);
}
text_update_cursor_moved(C);
WM_event_add_notifier(C, NC_TEXT | NA_EDITED, text);
return OPERATOR_FINISHED;
}
void TEXT_OT_previous_marker(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Previous Marker";
ot->idname = "TEXT_OT_previous_marker";
ot->description = "Move to previous marker";
/* api callbacks */
ot->exec = text_previous_marker_exec;
ot->poll = text_edit_poll;
}
/******************* next marker operator *********************/
static int text_next_marker_exec(bContext *C, wmOperator *UNUSED(op))
{
Text *text = CTX_data_edit_text(C);
TextMarker *mrk;
int lineno;
lineno = txt_get_span(text->lines.first, text->curl);
mrk = text->markers.first;
while (mrk && (mrk->lineno < lineno || (mrk->lineno == lineno && mrk->start <= text->curc)))
mrk = mrk->next;
if (!mrk) mrk = text->markers.first;
if (mrk) {
txt_move_to(text, mrk->lineno, mrk->start, 0);
txt_move_to(text, mrk->lineno, mrk->end, 1);
}
text_update_cursor_moved(C);
WM_event_add_notifier(C, NC_TEXT | NA_EDITED, text);
return OPERATOR_FINISHED;
}
void TEXT_OT_next_marker(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Next Marker";
ot->idname = "TEXT_OT_next_marker";
ot->description = "Move to next marker";
/* api callbacks */
ot->exec = text_next_marker_exec;
ot->poll = text_edit_poll;
}
/******************* clear all markers operator *********************/
static int text_clear_all_markers_exec(bContext *C, wmOperator *UNUSED(op))
{
Text *text = CTX_data_edit_text(C);
txt_clear_markers(text, 0, 0);
text_update_cursor_moved(C);
WM_event_add_notifier(C, NC_TEXT | NA_EDITED, text);
return OPERATOR_FINISHED;
}
void TEXT_OT_markers_clear(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Clear All Markers";
ot->idname = "TEXT_OT_markers_clear";
ot->description = "Clear all markers";
/* api callbacks */
ot->exec = text_clear_all_markers_exec;
ot->poll = text_edit_poll;
}
/************************ move operator ************************/
static EnumPropertyItem move_type_items[] = {
@ -2956,14 +2858,13 @@ void TEXT_OT_insert(wmOperatorType *ot)
/* mode */
#define TEXT_FIND 0
#define TEXT_REPLACE 1
#define TEXT_MARK_ALL 2
static int text_find_and_replace(bContext *C, wmOperator *op, short mode)
{
Main *bmain = CTX_data_main(C);
SpaceText *st = CTX_wm_space_text(C);
Text *start = NULL, *text = st->text;
int flags, first = 1;
Text *text = st->text;
int flags;
int found = 0;
char *tmp;
@ -2972,79 +2873,48 @@ static int text_find_and_replace(bContext *C, wmOperator *op, short mode)
flags = st->flags;
if (flags & ST_FIND_ALL)
flags ^= ST_FIND_WRAP;
flags &= ~ST_FIND_WRAP;
do {
int proceed = 0;
/* Replace current */
if (mode != TEXT_FIND && txt_has_sel(text)) {
tmp = txt_sel_to_buf(text);
if (first) {
if (text->markers.first)
if (flags & ST_MATCH_CASE) found = strcmp(st->findstr, tmp) == 0;
else found = BLI_strcasecmp(st->findstr, tmp) == 0;
if (found) {
if (mode == TEXT_REPLACE) {
txt_insert_buf(text, st->replacestr);
if (text->curl && text->curl->format) {
MEM_freeN(text->curl->format);
text->curl->format = NULL;
}
text_update_cursor_moved(C);
WM_event_add_notifier(C, NC_TEXT | NA_EDITED, text);
txt_clear_markers(text, TMARK_GRP_FINDALL, 0);
}
first = 0;
/* Replace current */
if (mode != TEXT_FIND && txt_has_sel(text)) {
tmp = txt_sel_to_buf(text);
if (flags & ST_MATCH_CASE) proceed = strcmp(st->findstr, tmp) == 0;
else proceed = BLI_strcasecmp(st->findstr, tmp) == 0;
if (proceed) {
if (mode == TEXT_REPLACE) {
txt_insert_buf(text, st->replacestr);
if (text->curl && text->curl->format) {
MEM_freeN(text->curl->format);
text->curl->format = NULL;
}
text_update_cursor_moved(C);
WM_event_add_notifier(C, NC_TEXT | NA_EDITED, text);
text_drawcache_tag_update(CTX_wm_space_text(C), 1);
}
else if (mode == TEXT_MARK_ALL) {
unsigned char color[4];
UI_GetThemeColor4ubv(TH_SHADE2, color);
if (txt_find_marker(text, text->curl, text->selc, TMARK_GRP_FINDALL, 0)) {
if (tmp) MEM_freeN(tmp), tmp = NULL;
break;
}
txt_add_marker(text, text->curl, text->curc, text->selc, color, TMARK_GRP_FINDALL, TMARK_EDITALL);
text_update_cursor_moved(C);
WM_event_add_notifier(C, NC_TEXT | NA_EDITED, text);
}
text_drawcache_tag_update(CTX_wm_space_text(C), 1);
}
MEM_freeN(tmp);
tmp = NULL;
}
MEM_freeN(tmp);
tmp = NULL;
}
/* Find next */
if (txt_find_string(text, st->findstr, flags & ST_FIND_WRAP, flags & ST_MATCH_CASE)) {
text_update_cursor_moved(C);
WM_event_add_notifier(C, NC_TEXT | ND_CURSOR, text);
}
else if (flags & ST_FIND_ALL) {
if (text == start) break;
if (!start) start = text;
if (text->id.next)
text = st->text = text->id.next;
else
text = st->text = bmain->text.first;
txt_move_toline(text, 0, 0);
text_update_cursor_moved(C);
WM_event_add_notifier(C, NC_TEXT | ND_CURSOR, text);
first = 1;
}
else {
if (!found && !proceed) BKE_reportf(op->reports, RPT_ERROR, "Text not found: %s", st->findstr);
break;
}
found = 1;
} while (mode == TEXT_MARK_ALL);
/* Find next */
if (txt_find_string(text, st->findstr, flags & ST_FIND_WRAP, flags & ST_MATCH_CASE)) {
text_update_cursor_moved(C);
WM_event_add_notifier(C, NC_TEXT | ND_CURSOR, text);
}
else if (flags & ST_FIND_ALL) {
if (text->id.next)
text = st->text = text->id.next;
else
text = st->text = bmain->text.first;
txt_move_toline(text, 0, 0);
text_update_cursor_moved(C);
WM_event_add_notifier(C, NC_TEXT | ND_CURSOR, text);
}
else {
if (!found) BKE_reportf(op->reports, RPT_ERROR, "Text not found: %s", st->findstr);
}
return OPERATOR_FINISHED;
}
@ -3085,25 +2955,6 @@ void TEXT_OT_replace(wmOperatorType *ot)
ot->poll = text_space_edit_poll;
}
/******************* mark all operator *********************/
static int text_mark_all_exec(bContext *C, wmOperator *op)
{
return text_find_and_replace(C, op, TEXT_MARK_ALL);
}
void TEXT_OT_mark_all(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Mark All";
ot->idname = "TEXT_OT_mark_all";
ot->description = "Mark all specified text";
/* api callbacks */
ot->exec = text_mark_all_exec;
ot->poll = text_space_edit_poll;
}
/******************* find set selected *********************/
static int text_find_set_selected_exec(bContext *C, wmOperator *op)

174
source/blender/editors/space_text/text_python.c
View File

@ -359,177 +359,3 @@ static short UNUSED_FUNCTION(do_texttools) (SpaceText * st, char ascii, unsigned
return swallow;
}
static short UNUSED_FUNCTION(do_textmarkers) (SpaceText * st, char ascii, unsigned short evnt, short val)
{
Text *text;
TextMarker *marker, *mrk, *nxt;
int c, s, draw = 0, swallow = 0;
int qual = 0; // XXX
text = st->text;
if (!text || text->id.lib || text->curl != text->sell) return 0;
marker = txt_find_marker(text, text->sell, text->selc, 0, 0);
if (marker && (marker->start > text->curc || marker->end < text->curc))
marker = NULL;
if (!marker) {
/* Find the next temporary marker */
if (evnt == TABKEY) {
int lineno = txt_get_span(text->lines.first, text->curl);
mrk = text->markers.first;
while (mrk) {
if (!marker && (mrk->flags & TMARK_TEMP)) marker = mrk;
if ((mrk->flags & TMARK_TEMP) && (mrk->lineno > lineno || (mrk->lineno == lineno && mrk->end > text->curc))) {
marker = mrk;
break;
}
mrk = mrk->next;
}
if (marker) {
txt_move_to(text, marker->lineno, marker->start, 0);
txt_move_to(text, marker->lineno, marker->end, 1);
// XXX text_update_cursor_moved(C);
// XXX WM_event_add_notifier(C, NC_TEXT|ND_CURSOR, text);
evnt = ascii = val = 0;
draw = 1;
swallow = 1;
}
}
else if (evnt == ESCKEY) {
if (txt_clear_markers(text, 0, TMARK_TEMP)) swallow = 1;
else if (txt_clear_markers(text, 0, 0)) swallow = 1;
else return 0;
evnt = ascii = val = 0;
draw = 1;
}
if (!swallow) return 0;
}
if (ascii) {
if (marker->flags & TMARK_EDITALL) {
c = text->curc - marker->start;
s = text->selc - marker->start;
if (s < 0 || s > marker->end - marker->start) return 0;
mrk = txt_next_marker(text, marker);
while (mrk) {
nxt = txt_next_marker(text, mrk); /* mrk may become invalid */
txt_move_to(text, mrk->lineno, mrk->start + c, 0);
if (s != c) txt_move_to(text, mrk->lineno, mrk->start + s, 1);
if (st->overwrite) {
if (txt_replace_char(text, ascii))
text_update_line_edited(st->text->curl);
}
else {
if (txt_add_char(text, ascii)) {
text_update_line_edited(st->text->curl);
}
}
if (mrk == marker || mrk == nxt) break;
mrk = nxt;
}
swallow = 1;
draw = 1;
}
}
else if (val) {
switch (evnt) {
case BACKSPACEKEY:
if (marker->flags & TMARK_EDITALL) {
c = text->curc - marker->start;
s = text->selc - marker->start;
if (s < 0 || s > marker->end - marker->start) return 0;
mrk = txt_next_marker(text, marker);
while (mrk) {
nxt = txt_next_marker(text, mrk); /* mrk may become invalid */
txt_move_to(text, mrk->lineno, mrk->start + c, 0);
if (s != c) txt_move_to(text, mrk->lineno, mrk->start + s, 1);
txt_backspace_char(text);
text_update_line_edited(st->text->curl);
if (mrk == marker || mrk == nxt) break;
mrk = nxt;
}
swallow = 1;
draw = 1;
}
break;
case DELKEY:
if (marker->flags & TMARK_EDITALL) {
c = text->curc - marker->start;
s = text->selc - marker->start;
if (s < 0 || s > marker->end - marker->start) return 0;
mrk = txt_next_marker(text, marker);
while (mrk) {
nxt = txt_next_marker(text, mrk); /* mrk may become invalid */
txt_move_to(text, mrk->lineno, mrk->start + c, 0);
if (s != c) txt_move_to(text, mrk->lineno, mrk->start + s, 1);
txt_delete_char(text);
text_update_line_edited(st->text->curl);
if (mrk == marker || mrk == nxt) break;
mrk = nxt;
}
swallow = 1;
draw = 1;
}
break;
case TABKEY:
if (qual & LR_SHIFTKEY) {
nxt = marker->prev;
if (!nxt) nxt = text->markers.last;
}
else {
nxt = marker->next;
if (!nxt) nxt = text->markers.first;
}
if (marker->flags & TMARK_TEMP) {
if (nxt == marker) nxt = NULL;
BLI_freelinkN(&text->markers, marker);
}
mrk = nxt;
if (mrk) {
txt_move_to(text, mrk->lineno, mrk->start, 0);
txt_move_to(text, mrk->lineno, mrk->end, 1);
// XXX text_update_cursor_moved(C);
// XXX WM_event_add_notifier(C, NC_TEXT|ND_CURSOR, text);
}
swallow = 1;
draw = 1;
break;
/* Events that should clear markers */
case UKEY: if (!(qual & LR_ALTKEY)) break;
case ZKEY: if (evnt == ZKEY && !(qual & LR_CTRLKEY)) break;
case RETKEY:
case ESCKEY:
if (marker->flags & (TMARK_EDITALL | TMARK_TEMP))
txt_clear_markers(text, marker->group, 0);
else
BLI_freelinkN(&text->markers, marker);
swallow = 1;
draw = 1;
break;
case RIGHTMOUSE: /* Marker context menu? */
case LEFTMOUSE:
break;
case FKEY: /* Allow find */
if (qual & LR_SHIFTKEY) swallow = 1;
break;
default:
if (qual != 0 && qual != LR_SHIFTKEY)
swallow = 1; /* Swallow all other shortcut events */
}
}
if (draw) {
// XXX redraw_alltext();
}
return swallow;
}

10
source/blender/makesdna/DNA_text_types.h
View File

@ -44,15 +44,6 @@ typedef struct TextLine {
int len, blen; /* blen unused */
} TextLine;
typedef struct TextMarker {
struct TextMarker *next, *prev;
int lineno, start, end, pad1; /* line number and start/end character indices */
int group, flags; /* see BKE_text.h for flag defines */
unsigned char color[4], pad[4]; /* draw color of the marker */
} TextMarker;
typedef struct Text {
ID id;
@ -63,7 +54,6 @@ typedef struct Text {
ListBase lines;
TextLine *curl, *sell;
int curc, selc;
ListBase markers;
char *undo_buf;
int undo_pos, undo_len;

1
source/blender/makesrna/RNA_access.h
View File

@ -526,7 +526,6 @@ extern StructRNA RNA_TextBox;
extern StructRNA RNA_TextCharacterFormat;
extern StructRNA RNA_TextCurve;
extern StructRNA RNA_TextLine;
extern StructRNA RNA_TextMarker;
extern StructRNA RNA_Texture;
extern StructRNA RNA_TextureNode;
extern StructRNA RNA_TextureNodeBricks;

48
source/blender/makesrna/intern/rna_text.c
View File

@ -129,49 +129,6 @@ static void rna_def_text_line(BlenderRNA *brna)
RNA_def_property_update(prop, NC_TEXT | NA_EDITED, NULL);
}
static void rna_def_text_marker(BlenderRNA *brna)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, "TextMarker", NULL);
RNA_def_struct_ui_text(srna, "Text Marker", "Marker highlighting a portion of text in a Text datablock");
prop = RNA_def_property(srna, "line", PROP_INT, PROP_UNSIGNED);
RNA_def_property_int_sdna(prop, NULL, "lineno");
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Line", "Line in which the marker is located");
prop = RNA_def_property(srna, "character_index_start", PROP_INT, PROP_UNSIGNED);
RNA_def_property_int_sdna(prop, NULL, "start");
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Start", "Start position of the marker in the line");
prop = RNA_def_property(srna, "character_index_end", PROP_INT, PROP_UNSIGNED);
RNA_def_property_int_sdna(prop, NULL, "end");
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "End", "Start position of the marker in the line");
prop = RNA_def_property(srna, "group", PROP_INT, PROP_UNSIGNED);
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_range(prop, 0, (int)0xFFFF);
RNA_def_property_ui_text(prop, "Group", "");
prop = RNA_def_property(srna, "is_temporary", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flags", TMARK_TEMP);
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Temporary", "Marker is temporary");
prop = RNA_def_property(srna, "use_edit_all", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flags", TMARK_EDITALL);
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Edit All", "Edit all markers of the same group as one");
prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop, "Color", "Color to display the marker with");
}
static void rna_def_text(BlenderRNA *brna)
{
StructRNA *srna;
@ -241,17 +198,12 @@ static void rna_def_text(BlenderRNA *brna)
RNA_def_property_ui_text(prop, "Selection End Character",
"Index of character after end of selection in the selection end line");
prop = RNA_def_property(srna, "markers", PROP_COLLECTION, PROP_NONE);
RNA_def_property_struct_type(prop, "TextMarker");
RNA_def_property_ui_text(prop, "Markers", "Text markers highlighting part of the text");
RNA_api_text(srna);
}
void RNA_def_text(BlenderRNA *brna)
{
rna_def_text_line(brna);
rna_def_text_marker(brna);
rna_def_text(brna);
}