nc_color color_manager::name_to_color( const std::string &name ) const
{
auto const id = name_to_id( name );
auto &entry = color_array[id];
return entry.custom > 0 ? entry.custom : entry.color;
}
static int get_obj_id(const char* input, json_token_info_t* info)
{
json_rpc_instance table;
table.handlers = (json_rpc_handler_t*)obj_names;
table.num_of_handlers = num_of_obj_names;
const char* name = &input[info->name_start];
return name_to_id(name, &table);
}
void color_manager::finalize()
{
static const std::array<std::string, NUM_HL> hilights = {{
"",
"red",
"white",
"green",
"yellow",
"magenta",
"cyan"
}};
for( size_t i = 0; i < color_array.size(); i++ ) {
color_struct &entry = color_array[i];
entry.invert = get( entry.invert_id );
if( !entry.name_custom.empty() ) {
// Not using name_to_color because we want default color of this name
auto const id = name_to_id( entry.name_custom );
auto &other = color_array[id];
entry.custom = other.color;
}
if( !entry.name_invert_custom.empty() ) {
auto const id = name_to_id( entry.name_invert_custom );
auto &other = color_array[id];
entry.custom = other.color;
}
inverted_map[entry.color] = entry.col_id;
inverted_map[entry.invert] = entry.invert_id;
}
// Highlights in a next run, to make sure custom colors are set
for( size_t i = 0; i < color_array.size(); i++ ) {
color_struct &entry = color_array[i];
const std::string my_name = get_name( entry.color );
for( size_t j = 0; j < NUM_HL; j++ ) {
entry.highlight[j] = highlight_from_names( my_name, hilights[j] );
}
}
}
nc_color color_manager::highlight_from_names( const std::string &name, const std::string &bg_name ) const
{
/*
// Base Name Highlight Red BG White BG Green BG Yellow BG
add_hightlight("c_black", "h_black", "", "c_black_white", "c_black_green", "c_black_yellow", "c_black_magenta", "c_black_cyan");
add_hightlight("c_white", "h_white", "c_white_red", "c_white_white", "c_white_green", "c_white_yellow", "c_white_magenta", "c_white_cyan");
etc.
*/
std::string hi_name;
if( bg_name.empty() ) { //c_black -> h_black
hi_name = "h_" + name.substr(2, name.length() - 2);
} else {
hi_name = name + "_" + bg_name;
}
color_id id = name_to_id( hi_name );
return color_array[id].color;
}
void color_manager::deserialize(JsonIn &jsin)
{
jsin.start_array();
while (!jsin.end_array()) {
JsonObject joColors = jsin.get_object();
const std::string name = joColors.get_string("name");
const std::string name_custom = joColors.get_string("custom");
const std::string name_invert_custom = joColors.get_string("invertcustom");
color_id id = name_to_id( name );
auto &entry = color_array[id];
if ( !name_custom.empty() ) {
entry.name_custom = name_custom;
}
if ( !name_invert_custom.empty() ) {
entry.name_invert_custom = name_invert_custom;
}
}
}
static node::NodeIdentIFace* _make_ast_from_ticpp(TreeContext* tc, ticpp::Node* ticpp_node)
{
if(dynamic_cast<ticpp::Document*>(ticpp_node))
{
uint32_t lexer_id = 0;
node::SymbolNode* document_node = mvc::MVCModel::make_symbol(tc, lexer_id, 0);
if(ticpp_node->NoChildren())
return document_node;
ticpp::Iterator<ticpp::Node> p;
for(p = p.begin(ticpp_node); p != p.end(); p++)
document_node->push_back(_make_ast_from_ticpp(tc, p.Get()));
if(document_node->size() == 1)
{
node::NodeIdentIFace* root_node = (*document_node)[0];
root_node->detach();
tc->alloc()._free(document_node);
return root_node;
}
return document_node;
}
if(dynamic_cast<ticpp::Declaration*>(ticpp_node))
return NULL;
if(dynamic_cast<ticpp::Element*>(ticpp_node))
{
std::string block_name;
ticpp_node->GetValue(&block_name);
if(block_name == "NULL")
return NULL;
std::string node_typename;
uint32_t lexer_id = 0;
std::string node_value;
ticpp::Element* elem = dynamic_cast<ticpp::Element*>(ticpp_node);
if(elem)
{
std::map<std::string, std::string> attr_map; // in case you need it
ticpp::Iterator<ticpp::Attribute> q;
for(q = q.begin(elem); q != q.end(); q++)
{
std::string attr_name, attr_value;
q->GetName(&attr_name);
q->GetValue(&attr_value);
attr_map[attr_name] = attr_value;
}
if(attr_map.size())
{
node_typename = attr_map["type"];
node_value = attr_map["value"];
lexer_id = name_to_id(node_typename);
}
}
node::NodeIdentIFace* term_node = _make_term_from_typename(tc, node_typename, lexer_id, node_value);
if(term_node)
return term_node;
else
{
node::SymbolNode* symbol_node = mvc::MVCModel::make_symbol(tc, lexer_id, 0);
ticpp::Iterator<ticpp::Node> r;
for(r = r.begin(ticpp_node); r != r.end(); r++)
symbol_node->push_back(_make_ast_from_ticpp(tc, r.Get()));
return symbol_node;
}
}
return NULL;
}
char *ref_to_id(char *s)
{
if (isdigit(s[0]))
return s;
return name_to_id(s);
}
void color_manager::show_gui()
{
const int iHeaderHeight = 4;
const int iContentHeight = FULL_SCREEN_HEIGHT - 2 - iHeaderHeight;
const int iOffsetX = (TERMX > FULL_SCREEN_WIDTH) ? (TERMX - FULL_SCREEN_WIDTH) / 2 : 0;
const int iOffsetY = (TERMY > FULL_SCREEN_HEIGHT) ? (TERMY - FULL_SCREEN_HEIGHT) / 2 : 0;
std::vector<int> vLines;
vLines.push_back(-1);
vLines.push_back(48);
const int iTotalCols = vLines.size();
WINDOW *w_colors_help = newwin((FULL_SCREEN_HEIGHT / 2) - 2, FULL_SCREEN_WIDTH * 3 / 4,
7 + iOffsetY + (FULL_SCREEN_HEIGHT / 2) / 2, iOffsetX + 19 / 2);
WINDOW_PTR w_colors_helpptr( w_colors_help );
WINDOW *w_colors_border = newwin(FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, iOffsetY, iOffsetX);
WINDOW_PTR w_colors_borderptr( w_colors_border );
WINDOW *w_colors_header = newwin(iHeaderHeight, FULL_SCREEN_WIDTH - 2, 1 + iOffsetY,
1 + iOffsetX);
WINDOW_PTR w_colors_headerptr( w_colors_header );
WINDOW *w_colors = newwin(iContentHeight, FULL_SCREEN_WIDTH - 2, iHeaderHeight + 1 + iOffsetY,
1 + iOffsetX);
WINDOW_PTR w_colorsptr( w_colors );
draw_border( w_colors_border, BORDER_COLOR, _( " COLOR MANAGER " ) );
mvwputch(w_colors_border, 3, 0, c_ltgray, LINE_XXXO); // |-
mvwputch(w_colors_border, 3, 79, c_ltgray, LINE_XOXX); // -|
for (int i = 0; i < 78; i++) {
mvwputch(w_colors_header, 2, i, c_ltgray, LINE_OXOX); // Draw line under header
}
for( auto &iCol : vLines ) {
if ( iCol > -1 ) {
mvwputch(w_colors_border, FULL_SCREEN_HEIGHT - 1, iCol + 1, c_ltgray, LINE_XXOX); // _|_
mvwputch(w_colors_header, 2, iCol, c_ltgray, LINE_OXXX);
mvwputch(w_colors_header, 3, iCol, c_ltgray, LINE_XOXO);
}
}
wrefresh(w_colors_border);
int tmpx = 0;
tmpx += shortcut_print(w_colors_header, 0, tmpx, c_white, c_ltgreen, _("<R>emove custom color")) + 2;
tmpx += shortcut_print(w_colors_header, 0, tmpx, c_white, c_ltgreen, _("<Arrow Keys> To navigate")) + 2;
tmpx += shortcut_print(w_colors_header, 0, tmpx, c_white, c_ltgreen, _("<Enter>-Edit")) + 2;
shortcut_print(w_colors_header, 0, tmpx, c_white, c_ltgreen, _("Load <T>emplate"));
mvwprintz(w_colors_header, 1, 0, c_white, _("Some color changes may require a restart."));
mvwprintz(w_colors_header, 3, 3, c_white, _("Colorname"));
mvwprintz(w_colors_header, 3, 21, c_white, _("Normal"));
mvwprintz(w_colors_header, 3, 52, c_white, _("Invert"));
wrefresh(w_colors_header);
int iCurrentLine = 0;
int iCurrentCol = 1;
int iStartPos = 0;
const int iMaxColors = color_array.size();
bool bStuffChanged = false;
input_context ctxt("COLORS");
ctxt.register_cardinal();
ctxt.register_action("CONFIRM");
ctxt.register_action("QUIT");
ctxt.register_action("REMOVE_CUSTOM");
ctxt.register_action("LOAD_TEMPLATE");
ctxt.register_action("HELP_KEYBINDINGS");
std::map<std::string, color_struct> name_color_map;
for( const auto &pr : name_map ) {
name_color_map[pr.first] = color_array[pr.second];
}
while(true) {
// Clear all lines
for (int i = 0; i < iContentHeight; i++) {
for (int j = 0; j < 79; j++) {
mvwputch(w_colors, i, j, c_black, ' ');
for( auto &iCol : vLines ) {
if ( iCol == j ) {
mvwputch(w_colors, i, j, c_ltgray, LINE_XOXO);
}
}
}
}
calcStartPos(iStartPos, iCurrentLine, iContentHeight, iMaxColors);
draw_scrollbar(w_colors_border, iCurrentLine, iContentHeight, iMaxColors, 5);
wrefresh(w_colors_border);
auto iter = name_color_map.begin();
std::advance( iter, iStartPos );
std::string sActive = "";
// display colormanager
for (int i=iStartPos; iter != name_color_map.end(); ++iter, ++i) {
if (i >= iStartPos && i < iStartPos + ((iContentHeight > iMaxColors) ? iMaxColors : iContentHeight)) {
auto &entry = iter->second;
if (iCurrentLine == i) {
sActive = iter->first;
mvwprintz(w_colors, i - iStartPos, vLines[iCurrentCol-1] + 2, c_yellow, ">");
}
mvwprintz(w_colors, i - iStartPos, 3, c_white, iter->first.c_str()); //colorname
mvwprintz(w_colors, i - iStartPos, 21, entry.color, _("default")); //default color
if ( !entry.name_custom.empty() ) {
mvwprintz(w_colors, i - iStartPos, 30, name_color_map[entry.name_custom].color, entry.name_custom.c_str()); //custom color
}
mvwprintz(w_colors, i - iStartPos, 52, entry.invert, _("default")); //invert default color
if ( !entry.name_invert_custom.empty() ) {
mvwprintz(w_colors, i - iStartPos, 61, name_color_map[entry.name_invert_custom].color, entry.name_invert_custom.c_str()); //invert custom color
}
}
}
wrefresh(w_colors);
const std::string action = ctxt.handle_input();
if (action == "QUIT") {
break;
} else if (action == "UP") {
iCurrentLine--;
if (iCurrentLine < 0) {
iCurrentLine = iMaxColors - 1;
}
} else if (action == "DOWN") {
iCurrentLine++;
if (iCurrentLine >= (int)iMaxColors) {
iCurrentLine = 0;
}
} else if (action == "LEFT") {
iCurrentCol--;
if (iCurrentCol < 1) {
iCurrentCol = iTotalCols;
}
} else if (action == "RIGHT") {
iCurrentCol++;
if (iCurrentCol > iTotalCols) {
iCurrentCol = 1;
}
} else if (action == "REMOVE_CUSTOM") {
auto &entry = name_color_map[sActive];
if ( iCurrentCol == 1 && !entry.name_custom.empty() ) {
bStuffChanged = true;
entry.name_custom = "";
} else if ( iCurrentCol == 2 && !entry.name_invert_custom.empty() ) {
bStuffChanged = true;
entry.name_invert_custom = "";
}
finalize(); // Need to recalculate caches
} else if (action == "LOAD_TEMPLATE") {
auto vFiles = get_files_from_path(".json", FILENAMES["color_templates"], false, true);
if ( vFiles.size() > 0 ) {
uimenu ui_templates;
ui_templates.w_y = iHeaderHeight + 1 + iOffsetY;
ui_templates.w_height = 18;
ui_templates.return_invalid = true;
ui_templates.text = _("Color templates:");
for ( const auto& filename : vFiles ) {
ui_templates.addentry( filename.substr(filename.find_last_of("/") + 1) );
}
ui_templates.addentry(std::string(_("Cancel")));
ui_templates.query();
if ( (size_t)ui_templates.ret < vFiles.size() ) {
bStuffChanged = true;
clear();
load_default();
load_custom(vFiles[ui_templates.ret]);
name_color_map.clear();
for( const auto &pr : name_map ) {
name_color_map[pr.first] = color_array[pr.second];
}
}
}
finalize(); // Need to recalculate caches
} else if (action == "CONFIRM") {
uimenu ui_colors;
ui_colors.w_y = iHeaderHeight + 1 + iOffsetY;
ui_colors.w_height = 18;
ui_colors.return_invalid = true;
std::string sColorType = _("Normal");
std::string sSelected = name_color_map[sActive].name_custom;
if ( iCurrentCol == 2 ) {
sColorType = _("Invert");
sSelected = name_color_map[sActive].name_invert_custom;
}
ui_colors.text = string_format( _("Custom %s color:"), sColorType.c_str() );
int i = 0;
for ( auto &iter : name_color_map ) {
std::string sColor = iter.first;
std::string sType = _("default");
std::string name_custom = "";
if ( sSelected == sColor ) {
ui_colors.selected = i;
}
if ( !iter.second.name_custom.empty() ) {
name_custom = " <color_" + iter.second.name_custom + ">" + iter.second.name_custom + "</color>";
}
ui_colors.addentry(string_format( "%-17s <color_%s>%s</color>%s", iter.first.c_str(), sColor.c_str(), sType.c_str(), name_custom.c_str() ) );
i++;
}
ui_colors.addentry(std::string(_("Cancel")));
ui_colors.query();
if ( (size_t)ui_colors.ret < name_color_map.size() ) {
bStuffChanged = true;
iter = name_color_map.begin();
std::advance( iter, ui_colors.ret );
auto &entry = name_color_map[sActive];
if ( iCurrentCol == 1 ) {
entry.name_custom = iter->first;
} else if ( iCurrentCol == 2 ) {
entry.name_invert_custom = iter->first;
}
}
finalize(); // Need to recalculate caches
}
}
if( bStuffChanged && query_yn(_("Save changes?") ) ) {
for( const auto &pr : name_color_map ) {
color_id id = name_to_id( pr.first );
color_array[id].name_custom = pr.second.name_custom;
color_array[id].name_invert_custom = pr.second.name_invert_custom;
}
finalize();
save_custom();
clear();
load_default();
load_custom();
}
}
static int get_fcn_id(json_rpc_instance_t* self, const char* input, json_token_info_t* info)
{
const char* name = &input[info->values_start];
return name_to_id(name, self);
}
