2011-11-29 23:37:20 +01:00
|
|
|
#include "highlighters.hh"
|
2013-04-09 19:39:03 +02:00
|
|
|
|
2011-11-14 15:23:02 +01:00
|
|
|
#include "assert.hh"
|
2012-09-17 19:01:13 +02:00
|
|
|
#include "color_registry.hh"
|
2012-12-31 14:28:32 +01:00
|
|
|
#include "context.hh"
|
2013-04-09 19:39:03 +02:00
|
|
|
#include "option_types.hh"
|
|
|
|
#include "register_manager.hh"
|
2012-08-29 21:49:36 +02:00
|
|
|
#include "string.hh"
|
2012-10-08 14:27:43 +02:00
|
|
|
#include "utf8.hh"
|
2013-02-26 14:12:21 +01:00
|
|
|
#include "utf8_iterator.hh"
|
2013-04-09 19:39:03 +02:00
|
|
|
#include "window.hh"
|
2013-03-26 00:14:38 +01:00
|
|
|
|
2013-02-26 14:12:21 +01:00
|
|
|
#include <sstream>
|
|
|
|
#include <locale>
|
2011-11-08 15:28:01 +01:00
|
|
|
|
2011-09-30 21:16:23 +02:00
|
|
|
namespace Kakoune
|
|
|
|
{
|
|
|
|
|
2012-04-03 15:39:20 +02:00
|
|
|
using namespace std::placeholders;
|
|
|
|
|
2012-05-03 09:25:13 +02:00
|
|
|
typedef boost::regex_iterator<BufferIterator> RegexIterator;
|
|
|
|
|
2012-07-12 23:19:10 +02:00
|
|
|
template<typename T>
|
|
|
|
void highlight_range(DisplayBuffer& display_buffer,
|
2013-05-23 13:59:33 +02:00
|
|
|
BufferCoord begin, BufferCoord end,
|
2012-07-12 23:19:10 +02:00
|
|
|
bool skip_replaced, T func)
|
2011-09-30 21:16:23 +02:00
|
|
|
{
|
2012-08-10 14:20:15 +02:00
|
|
|
if (begin == end or end <= display_buffer.range().first
|
|
|
|
or begin >= display_buffer.range().second)
|
2012-07-12 23:51:13 +02:00
|
|
|
return;
|
|
|
|
|
2012-07-12 23:19:10 +02:00
|
|
|
for (auto& line : display_buffer.lines())
|
2011-09-30 21:16:23 +02:00
|
|
|
{
|
2013-07-23 20:11:26 +02:00
|
|
|
auto& range = line.range();
|
|
|
|
if (range.second <= begin or end < range.first)
|
2012-12-12 19:33:29 +01:00
|
|
|
continue;
|
|
|
|
|
|
|
|
for (auto atom_it = line.begin(); atom_it != line.end(); ++atom_it)
|
2012-07-03 23:23:07 +02:00
|
|
|
{
|
2013-07-24 14:55:57 +02:00
|
|
|
bool is_replaced = atom_it->type() == DisplayAtom::ReplacedBufferRange;
|
2011-11-14 15:23:02 +01:00
|
|
|
|
2013-07-24 14:55:57 +02:00
|
|
|
if (not atom_it->has_buffer_range() or
|
2012-12-12 19:33:29 +01:00
|
|
|
(skip_replaced and is_replaced))
|
|
|
|
continue;
|
2011-09-30 21:16:23 +02:00
|
|
|
|
2013-07-24 14:55:57 +02:00
|
|
|
if (end <= atom_it->begin() or begin >= atom_it->end())
|
2012-12-12 19:33:29 +01:00
|
|
|
continue;
|
2012-02-22 22:48:14 +01:00
|
|
|
|
2013-07-24 14:55:57 +02:00
|
|
|
if (not is_replaced and begin > atom_it->begin())
|
2012-12-12 19:33:29 +01:00
|
|
|
atom_it = ++line.split(atom_it, begin);
|
2011-11-14 15:23:02 +01:00
|
|
|
|
2013-07-24 14:55:57 +02:00
|
|
|
if (not is_replaced and end < atom_it->end())
|
2012-12-12 19:33:29 +01:00
|
|
|
{
|
|
|
|
atom_it = line.split(atom_it, end);
|
|
|
|
func(*atom_it);
|
|
|
|
++atom_it;
|
2012-07-12 23:19:10 +02:00
|
|
|
}
|
2012-12-12 19:33:29 +01:00
|
|
|
else
|
|
|
|
func(*atom_it);
|
2012-07-12 23:19:10 +02:00
|
|
|
}
|
2011-09-30 21:16:23 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-17 21:02:08 +02:00
|
|
|
typedef std::unordered_map<size_t, const ColorPair*> ColorSpec;
|
2012-08-15 17:08:48 +02:00
|
|
|
|
|
|
|
class RegexColorizer
|
2011-11-24 20:11:58 +01:00
|
|
|
{
|
2012-08-15 17:08:48 +02:00
|
|
|
public:
|
|
|
|
RegexColorizer(Regex regex, ColorSpec colors)
|
2013-11-19 00:17:06 +01:00
|
|
|
: m_regex(std::move(regex)), m_colors(std::move(colors))
|
2012-08-15 17:08:48 +02:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-05-23 13:59:33 +02:00
|
|
|
void operator()(const Window& window, DisplayBuffer& display_buffer)
|
2012-07-12 23:19:10 +02:00
|
|
|
{
|
2013-11-19 00:17:06 +01:00
|
|
|
const Buffer& buffer = window.buffer();
|
|
|
|
update_cache_ifn(buffer, display_buffer.range());
|
|
|
|
for (auto& match : m_caches[&buffer].m_matches)
|
2012-08-07 00:13:54 +02:00
|
|
|
{
|
2012-08-15 17:08:48 +02:00
|
|
|
for (size_t n = 0; n < match.size(); ++n)
|
|
|
|
{
|
|
|
|
auto col_it = m_colors.find(n);
|
|
|
|
if (col_it == m_colors.end())
|
|
|
|
continue;
|
|
|
|
|
2013-11-19 00:17:06 +01:00
|
|
|
highlight_range(display_buffer, match[n].first, match[n].second, true,
|
2013-03-06 20:25:23 +01:00
|
|
|
[&](DisplayAtom& atom) { atom.colors = *col_it->second; });
|
2012-08-15 17:08:48 +02:00
|
|
|
}
|
2012-08-07 00:13:54 +02:00
|
|
|
}
|
2012-07-12 23:19:10 +02:00
|
|
|
}
|
2012-08-15 17:08:48 +02:00
|
|
|
|
|
|
|
private:
|
2013-11-19 00:17:06 +01:00
|
|
|
struct MatchesCache
|
|
|
|
{
|
|
|
|
BufferRange m_range;
|
|
|
|
size_t m_timestamp;
|
|
|
|
std::vector<std::vector<std::pair<BufferCoord, BufferCoord>>> m_matches;
|
|
|
|
};
|
|
|
|
std::unordered_map<const Buffer*, MatchesCache> m_caches;
|
2012-08-15 17:08:48 +02:00
|
|
|
|
|
|
|
Regex m_regex;
|
|
|
|
ColorSpec m_colors;
|
|
|
|
|
2013-05-23 13:59:33 +02:00
|
|
|
void update_cache_ifn(const Buffer& buffer, const BufferRange& range)
|
2012-08-15 17:08:48 +02:00
|
|
|
{
|
2013-11-19 00:17:06 +01:00
|
|
|
MatchesCache& cache = m_caches[&buffer];
|
|
|
|
|
|
|
|
if (buffer.timestamp() == cache.m_timestamp and
|
|
|
|
range.first >= cache.m_range.first and
|
|
|
|
range.second <= cache.m_range.second)
|
2012-08-15 17:08:48 +02:00
|
|
|
return;
|
|
|
|
|
2013-11-19 00:17:06 +01:00
|
|
|
cache.m_range.first = buffer.clamp({range.first.line - 10, 0});
|
|
|
|
cache.m_range.second = buffer.next(buffer.clamp({range.second.line + 10, INT_MAX}));
|
|
|
|
cache.m_timestamp = buffer.timestamp();
|
2012-08-15 17:08:48 +02:00
|
|
|
|
2013-11-19 00:17:06 +01:00
|
|
|
cache.m_matches.clear();
|
|
|
|
RegexIterator re_it{buffer.iterator_at(cache.m_range.first),
|
|
|
|
buffer.iterator_at(cache.m_range.second), m_regex};
|
2012-08-15 17:08:48 +02:00
|
|
|
RegexIterator re_end;
|
|
|
|
for (; re_it != re_end; ++re_it)
|
2013-11-19 00:17:06 +01:00
|
|
|
{
|
|
|
|
cache.m_matches.emplace_back();
|
|
|
|
auto& match = cache.m_matches.back();
|
|
|
|
for (auto& sub : *re_it)
|
|
|
|
match.emplace_back(sub.first.coord(), sub.second.coord());
|
|
|
|
}
|
2012-08-15 17:08:48 +02:00
|
|
|
}
|
|
|
|
};
|
2011-11-24 20:11:58 +01:00
|
|
|
|
2013-07-26 01:17:12 +02:00
|
|
|
HighlighterAndId colorize_regex_factory(HighlighterParameters params, const Window&)
|
2011-11-10 15:28:38 +01:00
|
|
|
{
|
2012-08-07 00:13:54 +02:00
|
|
|
if (params.size() < 2)
|
2011-11-10 15:28:38 +01:00
|
|
|
throw runtime_error("wrong parameter count");
|
|
|
|
|
2012-08-07 00:32:21 +02:00
|
|
|
try
|
2012-08-07 00:13:54 +02:00
|
|
|
{
|
2012-10-01 20:20:08 +02:00
|
|
|
static Regex color_spec_ex(R"((\d+):(\w+(,\w+)?))");
|
2012-08-07 00:32:21 +02:00
|
|
|
ColorSpec colors;
|
|
|
|
for (auto it = params.begin() + 1; it != params.end(); ++it)
|
|
|
|
{
|
2013-03-29 14:21:55 +01:00
|
|
|
boost::smatch res;
|
2012-08-07 00:32:21 +02:00
|
|
|
if (not boost::regex_match(it->begin(), it->end(), res, color_spec_ex))
|
|
|
|
throw runtime_error("wrong colorspec: '" + *it +
|
|
|
|
"' expected <capture>:<fgcolor>[,<bgcolor>]");
|
|
|
|
|
2013-05-17 14:09:42 +02:00
|
|
|
int capture = str_to_int(res[1].str());
|
2012-09-17 21:02:08 +02:00
|
|
|
const ColorPair*& color = colors[capture];
|
2013-05-13 14:23:07 +02:00
|
|
|
color = &get_color(res[2].str());
|
2012-08-07 00:32:21 +02:00
|
|
|
}
|
2011-11-10 15:28:38 +01:00
|
|
|
|
2012-08-07 00:32:21 +02:00
|
|
|
String id = "colre'" + params[0] + "'";
|
2011-11-15 15:28:03 +01:00
|
|
|
|
2012-08-07 00:32:21 +02:00
|
|
|
Regex ex(params[0].begin(), params[0].end(),
|
|
|
|
boost::regex::perl | boost::regex::optimize);
|
|
|
|
|
2012-08-15 17:08:48 +02:00
|
|
|
return HighlighterAndId(id, RegexColorizer(std::move(ex),
|
|
|
|
std::move(colors)));
|
2012-08-08 19:02:36 +02:00
|
|
|
}
|
2012-08-07 00:32:21 +02:00
|
|
|
catch (boost::regex_error& err)
|
|
|
|
{
|
|
|
|
throw runtime_error(String("regex error: ") + err.what());
|
|
|
|
}
|
2011-11-10 15:28:38 +01:00
|
|
|
}
|
|
|
|
|
2013-03-26 14:26:59 +01:00
|
|
|
template<typename RegexGetter>
|
|
|
|
class DynamicRegexHighlighter
|
2012-12-31 14:28:32 +01:00
|
|
|
{
|
|
|
|
public:
|
2013-03-26 14:26:59 +01:00
|
|
|
DynamicRegexHighlighter(const ColorSpec& colors, RegexGetter getter)
|
|
|
|
: m_regex_getter(getter), m_colors(colors), m_colorizer(Regex(), m_colors) {}
|
2012-12-31 14:28:32 +01:00
|
|
|
|
2013-05-23 13:39:00 +02:00
|
|
|
void operator()(const Window& window, DisplayBuffer& display_buffer)
|
2012-12-31 14:28:32 +01:00
|
|
|
{
|
2013-11-01 20:22:34 +01:00
|
|
|
Regex regex = m_regex_getter(window);
|
2013-03-26 14:26:59 +01:00
|
|
|
if (regex != m_last_regex)
|
2012-12-31 14:28:32 +01:00
|
|
|
{
|
2013-03-26 14:26:59 +01:00
|
|
|
m_last_regex = regex;
|
|
|
|
if (not m_last_regex.empty())
|
|
|
|
m_colorizer = RegexColorizer{m_last_regex, m_colors};
|
2012-12-31 14:28:32 +01:00
|
|
|
}
|
2013-03-26 14:26:59 +01:00
|
|
|
if (not m_last_regex.empty())
|
2013-05-23 13:39:00 +02:00
|
|
|
m_colorizer(window, display_buffer);
|
2012-12-31 14:28:32 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2013-03-26 14:26:59 +01:00
|
|
|
Regex m_last_regex;
|
2013-01-04 18:39:13 +01:00
|
|
|
ColorSpec m_colors;
|
|
|
|
RegexColorizer m_colorizer;
|
2013-03-26 14:26:59 +01:00
|
|
|
RegexGetter m_regex_getter;
|
2012-12-31 14:28:32 +01:00
|
|
|
};
|
|
|
|
|
2013-07-26 01:17:12 +02:00
|
|
|
HighlighterAndId highlight_search_factory(HighlighterParameters params, const Window&)
|
2012-12-31 14:28:32 +01:00
|
|
|
{
|
|
|
|
if (params.size() != 1)
|
|
|
|
throw runtime_error("wrong parameter count");
|
|
|
|
try
|
|
|
|
{
|
2013-04-04 18:47:34 +02:00
|
|
|
ColorSpec colors { { 0, &get_color(params[0]) } };
|
2013-11-01 20:22:34 +01:00
|
|
|
auto get_regex = [](const Window&){
|
2013-03-26 14:26:59 +01:00
|
|
|
auto s = RegisterManager::instance()['/'].values(Context{});
|
|
|
|
return s.empty() ? Regex{} : Regex{s[0].begin(), s[0].end()};
|
|
|
|
};
|
|
|
|
return {"hlsearch", DynamicRegexHighlighter<decltype(get_regex)>{colors, get_regex}};
|
2012-12-31 14:28:32 +01:00
|
|
|
}
|
|
|
|
catch (boost::regex_error& err)
|
|
|
|
{
|
|
|
|
throw runtime_error(String("regex error: ") + err.what());
|
|
|
|
}
|
2013-04-03 19:20:38 +02:00
|
|
|
}
|
2012-12-31 14:28:32 +01:00
|
|
|
|
2013-11-01 20:22:34 +01:00
|
|
|
HighlighterAndId highlight_regex_option_factory(HighlighterParameters params, const Window&)
|
2013-03-26 14:26:59 +01:00
|
|
|
{
|
|
|
|
if (params.size() != 2)
|
|
|
|
throw runtime_error("wrong parameter count");
|
|
|
|
|
2013-04-04 18:47:34 +02:00
|
|
|
ColorSpec colors { { 0, &get_color(params[1]) } };
|
2013-03-26 14:26:59 +01:00
|
|
|
String option_name = params[0];
|
|
|
|
// verify option type now
|
2013-11-01 20:22:34 +01:00
|
|
|
GlobalOptions::instance()[option_name].get<Regex>();
|
2013-03-26 14:26:59 +01:00
|
|
|
|
2013-11-01 20:22:34 +01:00
|
|
|
auto get_regex = [option_name](const Window& window){ return window.options()[option_name].get<Regex>(); };
|
2013-03-26 14:26:59 +01:00
|
|
|
return {"hloption_" + option_name, DynamicRegexHighlighter<decltype(get_regex)>{colors, get_regex}};
|
2013-04-03 19:20:38 +02:00
|
|
|
}
|
2013-03-26 14:26:59 +01:00
|
|
|
|
2013-05-23 13:39:00 +02:00
|
|
|
void expand_tabulations(const Window& window, DisplayBuffer& display_buffer)
|
2011-10-12 20:52:22 +02:00
|
|
|
{
|
2013-05-23 13:39:00 +02:00
|
|
|
const int tabstop = window.options()["tabstop"].get<int>();
|
2013-05-23 13:59:33 +02:00
|
|
|
auto& buffer = window.buffer();
|
2012-07-12 23:19:10 +02:00
|
|
|
for (auto& line : display_buffer.lines())
|
2011-10-12 20:52:22 +02:00
|
|
|
{
|
2012-07-12 23:19:10 +02:00
|
|
|
for (auto atom_it = line.begin(); atom_it != line.end(); ++atom_it)
|
2011-10-12 20:52:22 +02:00
|
|
|
{
|
2013-07-24 14:55:57 +02:00
|
|
|
if (atom_it->type() != DisplayAtom::BufferRange)
|
2012-07-12 23:19:10 +02:00
|
|
|
continue;
|
2011-10-17 21:01:36 +02:00
|
|
|
|
2013-07-24 14:55:57 +02:00
|
|
|
auto begin = buffer.iterator_at(atom_it->begin());
|
|
|
|
auto end = buffer.iterator_at(atom_it->end());
|
2012-07-12 23:19:10 +02:00
|
|
|
for (BufferIterator it = begin; it != end; ++it)
|
|
|
|
{
|
|
|
|
if (*it == '\t')
|
2011-10-15 06:45:49 +02:00
|
|
|
{
|
2012-07-12 23:19:10 +02:00
|
|
|
if (it != begin)
|
2013-05-23 13:59:33 +02:00
|
|
|
atom_it = ++line.split(atom_it, it.coord());
|
2012-07-12 23:19:10 +02:00
|
|
|
if (it+1 != end)
|
2013-05-23 13:59:33 +02:00
|
|
|
atom_it = line.split(atom_it, (it+1).coord());
|
2012-07-12 23:19:10 +02:00
|
|
|
|
|
|
|
int column = 0;
|
2013-07-23 20:11:26 +02:00
|
|
|
for (auto line_it = buffer.iterator_at(it.coord().line);
|
2012-07-12 23:19:10 +02:00
|
|
|
line_it != it; ++line_it)
|
|
|
|
{
|
2013-04-09 20:04:11 +02:00
|
|
|
kak_assert(*line_it != '\n');
|
2012-07-12 23:19:10 +02:00
|
|
|
if (*line_it == '\t')
|
|
|
|
column += tabstop - (column % tabstop);
|
|
|
|
else
|
|
|
|
++column;
|
|
|
|
}
|
|
|
|
|
|
|
|
int count = tabstop - (column % tabstop);
|
|
|
|
String padding;
|
|
|
|
for (int i = 0; i < count; ++i)
|
|
|
|
padding += ' ';
|
2013-07-24 14:55:57 +02:00
|
|
|
atom_it->replace(padding);
|
2012-07-12 23:19:10 +02:00
|
|
|
break;
|
2011-10-15 06:45:49 +02:00
|
|
|
}
|
2011-10-12 20:52:22 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-23 13:39:00 +02:00
|
|
|
void show_line_numbers(const Window& window, DisplayBuffer& display_buffer)
|
2011-10-17 21:01:36 +02:00
|
|
|
{
|
2013-05-23 13:39:00 +02:00
|
|
|
LineCount last_line = window.buffer().line_count();
|
2012-02-22 21:43:59 +01:00
|
|
|
int digit_count = 0;
|
2012-08-22 23:33:52 +02:00
|
|
|
for (LineCount c = last_line; c > 0; c /= 10)
|
2012-02-22 21:43:59 +01:00
|
|
|
++digit_count;
|
|
|
|
|
2013-05-24 18:39:03 +02:00
|
|
|
char format[] = "%?d│";
|
2012-02-22 21:43:59 +01:00
|
|
|
format[1] = '0' + digit_count;
|
2013-04-04 18:47:34 +02:00
|
|
|
auto& colors = get_color("LineNumbers");
|
2012-07-12 23:19:10 +02:00
|
|
|
for (auto& line : display_buffer.lines())
|
2011-10-17 21:01:36 +02:00
|
|
|
{
|
2012-07-12 23:19:10 +02:00
|
|
|
char buffer[10];
|
2013-07-23 20:11:26 +02:00
|
|
|
snprintf(buffer, 10, format, (int)line.range().first.line + 1);
|
2013-07-24 14:55:57 +02:00
|
|
|
DisplayAtom atom{buffer};
|
2013-03-06 20:31:07 +01:00
|
|
|
atom.colors = colors;
|
2012-07-12 23:19:10 +02:00
|
|
|
line.insert(line.begin(), std::move(atom));
|
2011-10-17 21:01:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-03-19 14:04:24 +01:00
|
|
|
void highlight_selections(const Window& window, DisplayBuffer& display_buffer)
|
2012-04-03 15:22:07 +02:00
|
|
|
{
|
2013-03-19 14:04:24 +01:00
|
|
|
const bool only_cursor = window.is_editing() and window.options()["insert_hide_sel"].get<bool>();
|
2013-06-03 18:58:09 +02:00
|
|
|
const auto& buffer = window.buffer();
|
2013-03-19 14:04:24 +01:00
|
|
|
for (size_t i = 0; i < window.selections().size(); ++i)
|
2012-04-03 15:22:07 +02:00
|
|
|
{
|
2013-03-19 14:04:24 +01:00
|
|
|
auto& sel = window.selections()[i];
|
2013-03-01 19:21:06 +01:00
|
|
|
const bool forward = sel.first() <= sel.last();
|
2013-06-03 18:58:09 +02:00
|
|
|
BufferCoord begin = forward ? sel.first() : buffer.char_next(sel.last());
|
|
|
|
BufferCoord end = forward ? sel.last() : buffer.char_next(sel.first());
|
2013-03-01 19:21:06 +01:00
|
|
|
|
2013-03-19 14:04:24 +01:00
|
|
|
const bool primary = (i == window.main_selection_index());
|
|
|
|
if (not only_cursor)
|
|
|
|
{
|
2013-04-04 18:47:34 +02:00
|
|
|
ColorPair sel_colors = get_color(primary ? "PrimarySelection" : "SecondarySelection");
|
2013-06-03 18:58:09 +02:00
|
|
|
highlight_range(display_buffer, begin, end, false,
|
2013-03-19 14:04:24 +01:00
|
|
|
[&](DisplayAtom& atom) { atom.colors = sel_colors; });
|
|
|
|
}
|
2013-04-04 18:47:34 +02:00
|
|
|
ColorPair cur_colors = get_color(primary ? "PrimaryCursor" : "SecondaryCursor");
|
2013-06-03 18:58:09 +02:00
|
|
|
highlight_range(display_buffer, sel.last(), buffer.char_next(sel.last()), false,
|
2013-03-06 20:31:07 +01:00
|
|
|
[&](DisplayAtom& atom) { atom.colors = cur_colors; });
|
2012-04-03 15:22:07 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-23 13:59:33 +02:00
|
|
|
void expand_unprintable(const Window& window, DisplayBuffer& display_buffer)
|
2013-02-26 14:12:21 +01:00
|
|
|
{
|
2013-05-23 13:59:33 +02:00
|
|
|
auto& buffer = window.buffer();
|
2013-02-26 14:12:21 +01:00
|
|
|
for (auto& line : display_buffer.lines())
|
|
|
|
{
|
2013-03-18 23:35:23 +01:00
|
|
|
for (auto atom_it = line.begin(); atom_it != line.end(); ++atom_it)
|
2013-02-26 14:12:21 +01:00
|
|
|
{
|
2013-07-24 14:55:57 +02:00
|
|
|
if (atom_it->type() == DisplayAtom::BufferRange)
|
2013-02-26 14:12:21 +01:00
|
|
|
{
|
2013-03-18 23:35:23 +01:00
|
|
|
using Utf8It = utf8::utf8_iterator<BufferIterator, utf8::InvalidBytePolicy::Pass>;
|
2013-07-24 14:55:57 +02:00
|
|
|
for (Utf8It it = buffer.iterator_at(atom_it->begin()),
|
|
|
|
end = buffer.iterator_at(atom_it->end()); it != end; ++it)
|
2013-02-26 14:12:21 +01:00
|
|
|
{
|
|
|
|
Codepoint cp = *it;
|
2013-07-18 21:58:11 +02:00
|
|
|
if (cp != '\n' and iscntrl((int)cp))
|
2013-02-26 14:12:21 +01:00
|
|
|
{
|
|
|
|
std::ostringstream oss;
|
|
|
|
oss << "U+" << std::hex << cp;
|
|
|
|
String str = oss.str();
|
2013-07-24 14:55:57 +02:00
|
|
|
if (it.base().coord() != atom_it->begin())
|
2013-06-05 19:19:35 +02:00
|
|
|
atom_it = ++line.split(atom_it, it.base().coord());
|
2013-07-24 14:55:57 +02:00
|
|
|
if ((it+1).base().coord() != atom_it->end())
|
2013-06-05 19:19:35 +02:00
|
|
|
atom_it = line.split(atom_it, (it+1).base().coord());
|
2013-07-24 14:55:57 +02:00
|
|
|
atom_it->replace(str);
|
2013-05-07 18:52:23 +02:00
|
|
|
atom_it->colors = { Colors::Red, Colors::Black };
|
2013-03-18 23:35:23 +01:00
|
|
|
break;
|
2013-02-26 14:12:21 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-26 01:17:12 +02:00
|
|
|
HighlighterAndId flag_lines_factory(HighlighterParameters params, Window& window)
|
2013-03-06 14:24:47 +01:00
|
|
|
{
|
|
|
|
if (params.size() != 2)
|
|
|
|
throw runtime_error("wrong parameter count");
|
|
|
|
|
2013-11-18 23:44:01 +01:00
|
|
|
const String& option_name = params[1];
|
|
|
|
Color bg = str_to_color(params[0]);
|
|
|
|
|
|
|
|
// throw if wrong option type
|
|
|
|
GlobalOptions::instance()[option_name].get<std::vector<LineAndFlag>>();
|
|
|
|
|
|
|
|
return {"hlflags_" + params[1],
|
|
|
|
[=](const Window& window, DisplayBuffer& display_buffer)
|
|
|
|
{
|
|
|
|
auto& lines_opt = window.options()[option_name];
|
|
|
|
auto& lines = lines_opt.get<std::vector<LineAndFlag>>();
|
|
|
|
|
|
|
|
CharCount width = 0;
|
|
|
|
for (auto& l : lines)
|
|
|
|
width = std::max(width, std::get<2>(l).char_length());
|
|
|
|
const String empty{' ', width};
|
|
|
|
for (auto& line : display_buffer.lines())
|
|
|
|
{
|
|
|
|
int line_num = (int)line.range().first.line + 1;
|
|
|
|
auto it = find_if(lines,
|
|
|
|
[&](const LineAndFlag& l)
|
|
|
|
{ return std::get<0>(l) == line_num; });
|
|
|
|
String content = it != lines.end() ? std::get<2>(*it) : empty;
|
|
|
|
content += String(' ', width - content.char_length());
|
|
|
|
DisplayAtom atom{std::move(content)};
|
|
|
|
atom.colors = { it != lines.end() ? std::get<1>(*it) : Colors::Default , bg };
|
|
|
|
line.insert(line.begin(), std::move(atom));
|
|
|
|
}
|
|
|
|
}};
|
2013-03-06 14:24:47 +01:00
|
|
|
}
|
|
|
|
|
2013-05-23 13:39:00 +02:00
|
|
|
template<void (*highlighter_func)(const Window&, DisplayBuffer&)>
|
2011-11-29 23:37:20 +01:00
|
|
|
class SimpleHighlighterFactory
|
2011-11-08 15:28:01 +01:00
|
|
|
{
|
|
|
|
public:
|
2012-04-14 03:17:09 +02:00
|
|
|
SimpleHighlighterFactory(const String& id) : m_id(id) {}
|
2011-11-08 15:28:01 +01:00
|
|
|
|
2013-07-26 01:17:12 +02:00
|
|
|
HighlighterAndId operator()(HighlighterParameters params, const Window&) const
|
2011-11-08 15:28:01 +01:00
|
|
|
{
|
2011-11-29 23:37:20 +01:00
|
|
|
return HighlighterAndId(m_id, HighlighterFunc(highlighter_func));
|
2011-11-08 15:28:01 +01:00
|
|
|
}
|
|
|
|
private:
|
2012-04-14 03:17:09 +02:00
|
|
|
String m_id;
|
2011-11-08 15:28:01 +01:00
|
|
|
};
|
|
|
|
|
2013-07-26 01:17:12 +02:00
|
|
|
HighlighterAndId highlighter_group_factory(HighlighterParameters params, const Window&)
|
2012-01-15 14:45:18 +01:00
|
|
|
{
|
|
|
|
if (params.size() != 1)
|
|
|
|
throw runtime_error("wrong parameter count");
|
|
|
|
|
|
|
|
return HighlighterAndId(params[0], HighlighterGroup());
|
|
|
|
}
|
|
|
|
|
2011-11-29 23:37:20 +01:00
|
|
|
void register_highlighters()
|
2011-11-08 15:28:01 +01:00
|
|
|
{
|
2011-11-29 23:37:20 +01:00
|
|
|
HighlighterRegistry& registry = HighlighterRegistry::instance();
|
2011-11-15 15:28:03 +01:00
|
|
|
|
2013-03-01 14:30:30 +01:00
|
|
|
registry.register_func("number_lines", SimpleHighlighterFactory<show_line_numbers>("number_lines"));
|
2012-11-23 13:40:20 +01:00
|
|
|
registry.register_func("regex", colorize_regex_factory);
|
2013-03-26 14:26:59 +01:00
|
|
|
registry.register_func("regex_option", highlight_regex_option_factory);
|
2012-12-31 14:28:32 +01:00
|
|
|
registry.register_func("search", highlight_search_factory);
|
2012-11-23 13:40:20 +01:00
|
|
|
registry.register_func("group", highlighter_group_factory);
|
2013-03-06 14:24:47 +01:00
|
|
|
registry.register_func("flag_lines", flag_lines_factory);
|
2011-11-08 15:28:01 +01:00
|
|
|
}
|
|
|
|
|
2011-09-30 21:16:23 +02:00
|
|
|
}
|