Obtaining colors from style

18 files changed, 159 insertions, 243 deletions

diff --git a/drape_frontend/apply_feature_functors.cpp b/drape_frontend/apply_feature_functors.cpp
index 4abac4082c..d730b42b2c 100644
--- a/drape_frontend/apply_feature_functors.cpp
+++ b/drape_frontend/apply_feature_functors.cpp
@@ -34,12 +34,28 @@
 namespace df
 {
 
+dp::Color ToDrapeColor(uint32_t src)
+{
+  return dp::Extract(src, 255 - (src >> 24));
+}
+
 namespace
 {
 double const kMinVisibleFontSize = 8.0;
 
-string const kStarSymbol = "★";
-string const kPriceSymbol = "$";
+std::string const kStarSymbol = "★";
+std::string const kPriceSymbol = "$";
+
+df::ColorConstant const kPoiHotelTextOutlineColor = "PoiHotelTextOutline";
+df::ColorConstant const kRoadShieldAddTextColor = "RoadShieldAddText";
+df::ColorConstant const kRoadShieldAddTextOutlineColor = "RoadShieldAddTextOutline";
+df::ColorConstant const kRoadShieldBlackTextColor = "RoadShieldBlackText";
+df::ColorConstant const kRoadShieldWhiteTextColor = "RoadShieldWhiteText";
+df::ColorConstant const kRoadShieldUKYellowTextColor = "RoadShieldUKYellowText";
+df::ColorConstant const kRoadShieldGreenBackgroundColor = "RoadShieldGreenBackground";
+df::ColorConstant const kRoadShieldBlueBackgroundColor = "RoadShieldBlueBackground";
+df::ColorConstant const kRoadShieldRedBackgroundColor = "RoadShieldRedBackground";
+df::ColorConstant const kRoadShieldOrangeBackgroundColor = "RoadShieldOrangeBackground";
 
 int const kLineSimplifyLevelStart = 10;
 int const kLineSimplifyLevelEnd = 12;
@@ -48,11 +64,6 @@ double const kPathTextBaseTextIndex = 0;
 double const kPathTextBaseTextStep = 100;
 double const kShieldBaseTextIndex = 1000;
 
-dp::Color ToDrapeColor(uint32_t src)
-{
-  return dp::Extract(src, 255 - (src >> 24));
-}
-
 #ifdef CALC_FILTERED_POINTS
 class LinesStat
 {
@@ -264,8 +275,7 @@ bool IsColoredRoadShield(ftypes::RoadShield const & shield)
          shield.m_type == ftypes::RoadShieldType::Generic_Orange;
 }
 
-dp::FontDecl GetRoadShieldTextFont(MapStyle const & style, dp::FontDecl const & baseFont,
-                                   ftypes::RoadShield const & shield)
+dp::FontDecl GetRoadShieldTextFont(dp::FontDecl const & baseFont, ftypes::RoadShield const & shield)
 {
   dp::FontDecl f = baseFont;
   f.m_outlineColor = dp::Color::Transparent();
@@ -273,36 +283,37 @@ dp::FontDecl GetRoadShieldTextFont(MapStyle const & style, dp::FontDecl const &
   using ftypes::RoadShieldType;
 
   static std::unordered_map<int, df::ColorConstant> kColors = {
-      {my::Key(RoadShieldType::Generic_Green), df::RoadShieldWhiteText},
-      {my::Key(RoadShieldType::Generic_Blue), df::RoadShieldWhiteText},
-      {my::Key(RoadShieldType::UK_Highway), df::RoadShieldUKYellowText},
-      {my::Key(RoadShieldType::US_Interstate), df::RoadShieldWhiteText},
-      {my::Key(RoadShieldType::US_Highway), df::RoadShieldBlackText},
-      {my::Key(RoadShieldType::Generic_Red), df::RoadShieldWhiteText},
-      {my::Key(RoadShieldType::Generic_Orange), df::RoadShieldBlackText}};
+      {my::Key(RoadShieldType::Generic_Green), kRoadShieldWhiteTextColor},
+      {my::Key(RoadShieldType::Generic_Blue), kRoadShieldWhiteTextColor},
+      {my::Key(RoadShieldType::UK_Highway), kRoadShieldUKYellowTextColor},
+      {my::Key(RoadShieldType::US_Interstate), kRoadShieldWhiteTextColor},
+      {my::Key(RoadShieldType::US_Highway), kRoadShieldBlackTextColor},
+      {my::Key(RoadShieldType::Generic_Red), kRoadShieldWhiteTextColor},
+      {my::Key(RoadShieldType::Generic_Orange), kRoadShieldBlackTextColor}
+  };
 
   auto it = kColors.find(my::Key(shield.m_type));
   if (it != kColors.end())
-    f.m_color = df::GetColorConstant(style, it->second);
+    f.m_color = df::GetColorConstant(it->second);
 
   return f;
 }
 
-dp::Color GetRoadShieldColor(MapStyle const & style, dp::Color const & baseColor,
-                             ftypes::RoadShield const & shield)
+dp::Color GetRoadShieldColor(dp::Color const & baseColor, ftypes::RoadShield const & shield)
 {
   using ftypes::RoadShieldType;
 
   static std::unordered_map<int, df::ColorConstant> kColors = {
-      {my::Key(RoadShieldType::Generic_Green), df::RoadShieldGreenBackground},
-      {my::Key(RoadShieldType::Generic_Blue), df::RoadShieldBlueBackground},
-      {my::Key(RoadShieldType::UK_Highway), df::RoadShieldGreenBackground},
-      {my::Key(RoadShieldType::Generic_Red), df::RoadShieldRedBackground},
-      {my::Key(RoadShieldType::Generic_Orange), df::RoadShieldOrangeBackground}};
+      {my::Key(RoadShieldType::Generic_Green), kRoadShieldGreenBackgroundColor},
+      {my::Key(RoadShieldType::Generic_Blue), kRoadShieldBlueBackgroundColor},
+      {my::Key(RoadShieldType::UK_Highway), kRoadShieldGreenBackgroundColor},
+      {my::Key(RoadShieldType::Generic_Red), kRoadShieldRedBackgroundColor},
+      {my::Key(RoadShieldType::Generic_Orange), kRoadShieldOrangeBackgroundColor}
+  };
 
   auto it = kColors.find(my::Key(shield.m_type));
   if (it != kColors.end())
-    return df::GetColorConstant(style, it->second);
+    return df::GetColorConstant(it->second);
 
   return baseColor;
 }
@@ -451,8 +462,7 @@ void ApplyPointFeature::ProcessRule(Stylist::TRuleWrapper const & rule)
     {
       params.m_primaryOptional = false;
       params.m_primaryTextFont.m_size *= 1.2;
-      auto const style = GetStyleReader().GetCurrentStyle();
-      params.m_primaryTextFont.m_outlineColor = df::GetColorConstant(style, df::PoiHotelTextOutline);
+      params.m_primaryTextFont.m_outlineColor = df::GetColorConstant(df::kPoiHotelTextOutlineColor);
       params.m_secondaryTextFont = params.m_primaryTextFont;
       params.m_secondaryText = ExtractHotelInfo();
       params.m_secondaryOptional = false;
@@ -825,13 +835,12 @@ void ApplyLineFeature::GetRoadShieldsViewParams(ftypes::RoadShield const & shiel
 
   string const & roadNumber = shield.m_name;
   float const mainScale = df::VisualParams::Instance().GetVisualScale();
-  auto const style = GetStyleReader().GetCurrentStyle();
   double const fontScale = df::VisualParams::Instance().GetFontScale();
 
   // Text properties.
   dp::FontDecl baseFont;
   ShieldRuleProtoToFontDecl(m_shieldRule, baseFont);
-  dp::FontDecl font = GetRoadShieldTextFont(style, baseFont, shield);
+  dp::FontDecl font = GetRoadShieldTextFont(baseFont, shield);
   textParams.m_tileCenter = m_tileRect.Center();
   textParams.m_depth = m_shieldDepth;
   textParams.m_minVisibleScale = m_minVisibleScale;
@@ -869,7 +878,7 @@ void ApplyLineFeature::GetRoadShieldsViewParams(ftypes::RoadShield const & shiel
     }
     symbolParams.m_sizeInPixels = m2::PointF(shieldWidth, shieldHeight);
     symbolParams.m_outlineWidth = GetRoadShieldOutlineWidth(symbolParams.m_outlineWidth, shield);
-    symbolParams.m_color = GetRoadShieldColor(style, symbolParams.m_color, shield);
+    symbolParams.m_color = GetRoadShieldColor(symbolParams.m_color, shield);
   }
 
   // Image symbol properties.
@@ -881,8 +890,8 @@ void ApplyLineFeature::GetRoadShieldsViewParams(ftypes::RoadShield const & shiel
       textParams.m_anchor = dp::Top;
       textParams.m_secondaryText = shield.m_additionalText;
       textParams.m_secondaryTextFont = textParams.m_primaryTextFont;
-      textParams.m_secondaryTextFont.m_color = df::GetColorConstant(style, df::RoadShieldBlackText);
-      textParams.m_secondaryTextFont.m_outlineColor = df::GetColorConstant(style, df::RoadShieldWhiteText);
+      textParams.m_secondaryTextFont.m_color = df::GetColorConstant(kRoadShieldBlackTextColor);
+      textParams.m_secondaryTextFont.m_outlineColor = df::GetColorConstant(kRoadShieldWhiteTextColor);
       textParams.m_primaryOffset = m2::PointF(0.0f, -0.5f * textParams.m_primaryTextFont.m_size);
       textParams.m_secondaryTextFont.m_size *= 0.9f;
       textParams.m_secondaryOffset = m2::PointF(0.0f, 3.0f * mainScale);
diff --git a/drape_frontend/apply_feature_functors.hpp b/drape_frontend/apply_feature_functors.hpp
index 827ecacd26..8440d35c6c 100644
--- a/drape_frontend/apply_feature_functors.hpp
+++ b/drape_frontend/apply_feature_functors.hpp
@@ -168,4 +168,6 @@ private:
 #endif
 };
 
+extern dp::Color ToDrapeColor(uint32_t src);
+
 } // namespace df
diff --git a/drape_frontend/arrow3d.cpp b/drape_frontend/arrow3d.cpp
index 45b6d399ad..22c318d00c 100644
--- a/drape_frontend/arrow3d.cpp
+++ b/drape_frontend/arrow3d.cpp
@@ -31,6 +31,11 @@ float const kOutlineScale = 1.2f;
 
 int constexpr kComponentsInVertex = 4;
 
+df::ColorConstant const kArrow3DShadowColor = "Arrow3DShadow";
+df::ColorConstant const kArrow3DObsoleteColor = "Arrow3DObsolete";
+df::ColorConstant const kArrow3DColor = "Arrow3D";
+df::ColorConstant const kArrow3DOutlineColor = "Arrow3DOutline";
+
 Arrow3d::Arrow3d()
   : m_state(gpu::ARROW_3D_PROGRAM, dp::GLState::OverlayLayer)
 {
@@ -132,22 +137,20 @@ void Arrow3d::Render(ScreenBase const & screen, ref_ptr<dp::GpuProgramManager> m
     m_isInitialized = true;
   }
 
-  auto const & style = GetStyleReader().GetCurrentStyle();
-
   // Render shadow.
   if (screen.isPerspective())
   {
     ref_ptr<dp::GpuProgram> shadowProgram = mng->GetProgram(gpu::ARROW_3D_SHADOW_PROGRAM);
-    RenderArrow(screen, shadowProgram, df::GetColorConstant(style, df::Arrow3DShadow), 0.05f /* dz */,
+    RenderArrow(screen, shadowProgram, df::GetColorConstant(df::kArrow3DShadowColor), 0.05f /* dz */,
                 routingMode ? kOutlineScale : 1.0f /* scaleFactor */, false /* hasNormals */);
   }
 
-  dp::Color const color = df::GetColorConstant(style, m_obsoletePosition ? df::Arrow3DObsolete : df::Arrow3D);
+  dp::Color const color = df::GetColorConstant(m_obsoletePosition ? df::kArrow3DObsoleteColor : df::kArrow3DColor);
 
   // Render outline.
   if (routingMode)
   {
-    dp::Color const outlineColor = df::GetColorConstant(style, df::Arrow3DOutline);
+    dp::Color const outlineColor = df::GetColorConstant(df::kArrow3DOutlineColor);
     ref_ptr<dp::GpuProgram> outlineProgram = mng->GetProgram(gpu::ARROW_3D_OUTLINE_PROGRAM);
     RenderArrow(screen, outlineProgram,
                 dp::Color(outlineColor.GetRed(), outlineColor.GetGreen(), outlineColor.GetBlue(), color.GetAlfa()),
diff --git a/drape_frontend/color_constants.cpp b/drape_frontend/color_constants.cpp
index 74cccd70fc..e8954b4636 100644
--- a/drape_frontend/color_constants.cpp
+++ b/drape_frontend/color_constants.cpp
@@ -1,112 +1,15 @@
 #include "drape_frontend/color_constants.hpp"
+#include "drape_frontend/apply_feature_functors.hpp"
 
-#include "base/assert.hpp"
+#include "indexer/drawing_rules.hpp"
 
-#include "std/array.hpp"
-#include "std/unordered_map.hpp"
+#include "base/assert.hpp"
 
 namespace df
 {
-
-unordered_map<int, unordered_map<int, dp::Color>> kColorConstants =
-{
-  { MapStyleClear,
-    {
-      { GuiText, dp::Color(77, 77, 77, 221) },
-      { MyPositionAccuracy, dp::Color(0, 0, 0, 20) },
-      { Selection, dp::Color(30, 150, 240, 164) },
-      { Route, dp::Color(0, 135, 255, 255) },
-      { RouteOutline, dp::Color(5, 95, 205, 255) },
-      { RouteTrafficG0, dp::Color(155, 35, 0, 255) },
-      { RouteTrafficG1, dp::Color(240, 60, 10, 255) },
-      { RouteTrafficG2, dp::Color(240, 60, 10, 255) },
-      { RouteTrafficG3, dp::Color(245, 215, 40, 127) },
-      { RoutePedestrian, dp::Color(29, 51, 158, 204) },
-      { RouteBicycle, dp::Color(156, 39, 176, 204) },
-      { Arrow3D, dp::Color(80, 170, 255, 255) },
-      { Arrow3DObsolete, dp::Color(130, 170, 200, 183) },
-      { Arrow3DShadow, dp::Color(60, 60, 60, 60) },
-      { Arrow3DOutline, dp::Color(255, 255, 255, 255) },
-      { TrackHumanSpeed, dp::Color(29, 51, 158, 255) },
-      { TrackCarSpeed, dp::Color(21, 121, 244, 255) },
-      { TrackPlaneSpeed, dp::Color(10, 196, 255, 255) },
-      { TrackUnknownDistance, dp::Color(97, 97, 97, 255) },
-      { TrafficG0, dp::Color(155, 35, 5, 255) },
-      { TrafficG1, dp::Color(230, 60, 55, 255) },
-      { TrafficG2, dp::Color(230, 60, 55, 255) },
-      { TrafficG3, dp::Color(250, 180, 35, 127) },
-      { TrafficG4, dp::Color(155, 175, 55, 255) },
-      { TrafficG5, dp::Color(70, 135, 85, 255) },
-      { TrafficTempBlock, dp::Color(70, 70, 70, 255) },
-      { TrafficUnknown, dp::Color(0, 0, 0, 0) },
-      { TrafficArrowLight, dp::Color(255, 255, 255, 255) },
-      { TrafficArrowDark, dp::Color(107, 81, 20, 255) },
-      { TrafficOutline, dp::Color(255, 255, 255, 255) },
-      { RoadShieldWhiteText, dp::Color(255, 255, 255, 255) },
-      { RoadShieldBlackText, dp::Color(0, 0, 0, 255) },
-      { RoadShieldUKYellowText, dp::Color(255, 204, 102, 255) },
-      { RoadShieldBlueBackground, dp::Color(46, 111, 201, 255) },
-      { RoadShieldGreenBackground, dp::Color(34, 114, 59, 255) },
-      { RoadShieldRedBackground, dp::Color(205, 40, 40, 255) },
-      { RoadShieldOrangeBackground, dp::Color(255, 190, 0, 255) },
-      { PoiHotelTextOutline, dp::Color(255, 255, 255, 153) },
-      { PoiDeletedMask, dp::Color(255, 255, 255, 76) },
-    }
-  },
-  { MapStyleDark,
-    {
-      { GuiText, dp::Color(255, 255, 255, 178) },
-      { MyPositionAccuracy, dp::Color(255, 255, 255, 15) },
-      { Selection, dp::Color(75, 185, 230, 164) },
-      { Route, dp::Color(0, 135, 255, 255) },
-      { RouteOutline, dp::Color(5, 95, 205, 255) },
-      { RouteTrafficG0, dp::Color(155, 35, 0, 255) },
-      { RouteTrafficG1, dp::Color(240, 60, 10, 255) },
-      { RouteTrafficG2, dp::Color(240, 60, 10, 255) },
-      { RouteTrafficG3, dp::Color(245, 215, 40, 127) },
-      { RoutePedestrian, dp::Color(255, 185, 75, 180) },
-      { RouteBicycle, dp::Color(255, 75, 140, 180) },
-      { Arrow3D, dp::Color(65, 200, 255, 255) },
-      { Arrow3DObsolete, dp::Color(130, 170, 200, 183) },
-      { Arrow3DShadow, dp::Color(60, 60, 60, 60) },
-      { Arrow3DOutline, dp::Color(255, 255, 255, 255) },
-      { TrackHumanSpeed, dp::Color(255, 152, 0, 255) },
-      { TrackCarSpeed, dp::Color(255, 202, 40, 255) },
-      { TrackPlaneSpeed, dp::Color(255, 245, 160, 255) },
-      { TrackUnknownDistance, dp::Color(150, 150, 150, 255) },
-      { TrafficG0, dp::Color(65, 15, 0, 255) },
-      { TrafficG1, dp::Color(120, 25, 25, 255) },
-      { TrafficG2, dp::Color(120, 25, 25, 255) },
-      { TrafficG3, dp::Color(140, 90, 0, 127) },
-      { TrafficG4, dp::Color(85, 85, 25, 255) },
-      { TrafficG5, dp::Color(40, 80, 50, 255) },
-      { TrafficTempBlock, dp::Color(35, 35, 35, 255) },
-      { TrafficUnknown, dp::Color(0, 0, 0, 0) },
-      { TrafficArrowLight, dp::Color(170, 170, 170, 255) },
-      { TrafficArrowDark, dp::Color(30, 30, 30, 255) },
-      { TrafficOutline, dp::Color(0, 0, 0, 255) },
-      { RoadShieldWhiteText, dp::Color(255, 255, 255, 255) },
-      { RoadShieldBlackText, dp::Color(0, 0, 0, 255) },
-      { RoadShieldUKYellowText, dp::Color(255, 204, 102, 255) },
-      { RoadShieldBlueBackground, dp::Color(46, 111, 201, 255) },
-      { RoadShieldGreenBackground, dp::Color(34, 114, 59, 255) },
-      { RoadShieldRedBackground, dp::Color(205, 40, 40, 255) },
-      { RoadShieldOrangeBackground, dp::Color(255, 190, 0, 255) },
-      { PoiHotelTextOutline, dp::Color(0, 0, 0, 153) },
-      { PoiDeletedMask, dp::Color(255, 255, 255, 76) },
-    }
-  },
-};
-
-dp::Color GetColorConstant(MapStyle style, ColorConstant constant)
+dp::Color GetColorConstant(ColorConstant const & constant)
 {
-  int const styleIndex = static_cast<int>(style);
-  int const colorIndex = static_cast<int>(constant);
-
-  ASSERT(kColorConstants.find(styleIndex) != kColorConstants.end(), ());
-  ASSERT(kColorConstants[styleIndex].find(colorIndex) != kColorConstants[styleIndex].end(), ());
-
-  return kColorConstants[styleIndex][colorIndex];
+  uint32_t const color = drule::rules().GetColor(constant);
+  return ToDrapeColor(color);
 }
-
 } // namespace df
diff --git a/drape_frontend/color_constants.hpp b/drape_frontend/color_constants.hpp
index 835e4d5834..1ac6c5da0f 100644
--- a/drape_frontend/color_constants.hpp
+++ b/drape_frontend/color_constants.hpp
@@ -2,54 +2,11 @@
 
 #include "drape/color.hpp"
 
-#include "indexer/map_style.hpp"
+#include <string>
 
 namespace df
 {
+using ColorConstant = std::string;
 
-enum ColorConstant
-{
-  GuiText,
-  MyPositionAccuracy,
-  Selection,
-  Route,
-  RouteOutline,
-  RouteTrafficG0,
-  RouteTrafficG1,
-  RouteTrafficG2,
-  RouteTrafficG3,
-  RoutePedestrian,
-  RouteBicycle,
-  Arrow3D,
-  Arrow3DObsolete,
-  Arrow3DShadow,
-  Arrow3DOutline,
-  TrackHumanSpeed,
-  TrackCarSpeed,
-  TrackPlaneSpeed,
-  TrackUnknownDistance,
-  TrafficG0,
-  TrafficG1,
-  TrafficG2,
-  TrafficG3,
-  TrafficG4,
-  TrafficG5,
-  TrafficTempBlock,
-  TrafficUnknown,
-  TrafficArrowLight,
-  TrafficArrowDark,
-  TrafficOutline,
-  RoadShieldWhiteText,
-  RoadShieldBlackText,
-  RoadShieldUKYellowText,
-  RoadShieldBlueBackground,
-  RoadShieldGreenBackground,
-  RoadShieldRedBackground,
-  RoadShieldOrangeBackground,
-  PoiHotelTextOutline,
-  PoiDeletedMask
-};
-
-dp::Color GetColorConstant(MapStyle style, ColorConstant constant);
-
-} // namespace df
+dp::Color GetColorConstant(ColorConstant const & constant);
+} //  namespace df
diff --git a/drape_frontend/gps_track_renderer.cpp b/drape_frontend/gps_track_renderer.cpp
index be3fae7272..d7494050f2 100644
--- a/drape_frontend/gps_track_renderer.cpp
+++ b/drape_frontend/gps_track_renderer.cpp
@@ -23,6 +23,11 @@ namespace
 
 //#define SHOW_RAW_POINTS
 
+df::ColorConstant const kTrackUnknownDistanceColor = "TrackUnknownDistance";
+df::ColorConstant const kTrackCarSpeedColor = "TrackCarSpeed";
+df::ColorConstant const kTrackPlaneSpeedColor = "TrackPlaneSpeed";
+df::ColorConstant const kTrackHumanSpeedColor = "TrackHumanSpeed";
+
 int const kMinVisibleZoomLevel = 5;
 
 size_t const kAveragePointsCount = 512;
@@ -164,7 +169,7 @@ dp::Color GpsTrackRenderer::CalculatePointColor(size_t pointIndex, m2::PointD co
 
   if ((end.m_timestamp - start.m_timestamp) > kUnknownDistanceTime)
   {
-    dp::Color const color = df::GetColorConstant(style, df::TrackUnknownDistance);
+    dp::Color const color = df::GetColorConstant(df::kTrackUnknownDistanceColor);
     return dp::Color(color.GetRed(), color.GetGreen(), color.GetBlue(), alpha);
   }
 
@@ -179,13 +184,12 @@ dp::Color GpsTrackRenderer::CalculatePointColor(size_t pointIndex, m2::PointD co
 
 dp::Color GpsTrackRenderer::GetColorBySpeed(double speed) const
 {
-  auto const style = GetStyleReader().GetCurrentStyle();
   if (speed > kHumanSpeed && speed <= kCarSpeed)
-    return df::GetColorConstant(style, df::TrackCarSpeed);
+    return df::GetColorConstant(df::kTrackCarSpeedColor);
   else if (speed > kCarSpeed)
-    return df::GetColorConstant(style, df::TrackPlaneSpeed);
+    return df::GetColorConstant(df::kTrackPlaneSpeedColor);
 
-  return df::GetColorConstant(style, df::TrackHumanSpeed);
+  return df::GetColorConstant(df::kTrackHumanSpeedColor);
 }
 
 void GpsTrackRenderer::RenderTrack(ScreenBase const & screen, int zoomLevel,
diff --git a/drape_frontend/gui/drape_gui.cpp b/drape_frontend/gui/drape_gui.cpp
index 263f50729a..2418cb9f04 100644
--- a/drape_frontend/gui/drape_gui.cpp
+++ b/drape_frontend/gui/drape_gui.cpp
@@ -11,6 +11,8 @@
 namespace gui
 {
 
+df::ColorConstant const kGuiTextColor = "GuiText";
+
 struct DrapeGui::Impl
 {
   DrapeGui::TLocalizeStringFn m_localizeFn;
@@ -37,7 +39,7 @@ RulerHelper & DrapeGui::GetRulerHelper()
 
 dp::FontDecl DrapeGui::GetGuiTextFont()
 {
-  return dp::FontDecl(df::GetColorConstant(GetStyleReader().GetCurrentStyle(), df::GuiText), 14);
+  return dp::FontDecl(df::GetColorConstant(kGuiTextColor), 14);
 }
 
 void DrapeGui::Destroy()
diff --git a/drape_frontend/my_position.cpp b/drape_frontend/my_position.cpp
index 081166d9d9..38bbd69c27 100644
--- a/drape_frontend/my_position.cpp
+++ b/drape_frontend/my_position.cpp
@@ -15,9 +15,9 @@
 
 namespace df
 {
-
 namespace
 {
+df::ColorConstant const kMyPositionAccuracyColor = "MyPositionAccuracy";
 
 struct Vertex
 {
@@ -51,8 +51,7 @@ dp::BindingInfo GetBindingInfo()
 
   return info;
 }
-
-} // namespace
+} //  namespace
 
 MyPosition::MyPosition(ref_ptr<dp::TextureManager> mng)
   : m_position(m2::PointF::Zero())
@@ -149,7 +148,7 @@ void MyPosition::CacheAccuracySector(ref_ptr<dp::TextureManager> mng)
   float const etalonSector = math::twicePi / static_cast<double>(TriangleCount);
 
   dp::TextureManager::ColorRegion color;
-  mng->GetColorRegion(df::GetColorConstant(GetStyleReader().GetCurrentStyle(), df::MyPositionAccuracy), color);
+  mng->GetColorRegion(df::GetColorConstant(df::kMyPositionAccuracyColor), color);
   glsl::vec2 colorCoord = glsl::ToVec2(color.GetTexRect().Center());
 
   buffer_vector<Vertex, TriangleCount> buffer;
diff --git a/drape_frontend/poi_symbol_shape.cpp b/drape_frontend/poi_symbol_shape.cpp
index b4bf326275..1295b246c8 100644
--- a/drape_frontend/poi_symbol_shape.cpp
+++ b/drape_frontend/poi_symbol_shape.cpp
@@ -14,6 +14,7 @@
 
 namespace
 {
+df::ColorConstant const kPoiDeletedMaskColor = "PoiDeletedMask";
 
 using SV = gpu::SolidTexturingVertex;
 using MV = gpu::MaskedTexturingVertex;
@@ -130,9 +131,8 @@ void PoiSymbolShape::Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManag
 
   if (m_params.m_obsoleteInEditor)
   {
-    dp::Color const mask = df::GetColorConstant(GetStyleReader().GetCurrentStyle(), df::PoiDeletedMask);
     dp::TextureManager::ColorRegion maskColorRegion;
-    textures->GetColorRegion(mask, maskColorRegion);
+    textures->GetColorRegion(df::GetColorConstant(kPoiDeletedMaskColor), maskColorRegion);
     Batch<MV>(batcher, move(handle), position, region, maskColorRegion);
   }
   else
diff --git a/drape_frontend/route_renderer.cpp b/drape_frontend/route_renderer.cpp
index 065b6e1f53..dbd295f4b1 100644
--- a/drape_frontend/route_renderer.cpp
+++ b/drape_frontend/route_renderer.cpp
@@ -16,6 +16,11 @@
 namespace df
 {
 
+std::string kRouteColor = "Route";
+std::string kRouteOutlineColor = "RouteOutline";
+std::string kRoutePedestrian = "RoutePedestrian";
+std::string kRouteBicycle = "RouteBicycle";
+
 namespace
 {
 
@@ -114,12 +119,9 @@ bool AreEqualArrowBorders(vector<ArrowBorders> const & borders1, vector<ArrowBor
   return true;
 }
 
-dp::Color GetOutlineColor(df::ColorConstant routeColor)
+dp::Color GetOutlineColor(df::ColorConstant const & routeColor)
 {
-  df::ColorConstant c = routeColor;
-  if (routeColor == df::ColorConstant::Route)
-    c = df::ColorConstant::RouteOutline;
-  return df::GetColorConstant(GetStyleReader().GetCurrentStyle(), c);
+  return df::GetColorConstant(routeColor == kRouteColor ? kRouteOutlineColor : routeColor);
 }
 
 } // namespace
@@ -137,7 +139,7 @@ void RouteRenderer::InterpolateByZoom(ScreenBase const & screen, ColorConstant c
   float const lerpCoef = zoomLevel - zoom;
 
   float const * halfWidthInPixel = kHalfWidthInPixelVehicle;
-  if (color != ColorConstant::Route)
+  if (color != kRouteColor)
     halfWidthInPixel = kHalfWidthInPixelOthers;
 
   if (index < scales::UPPER_STYLE_SCALE)
@@ -249,8 +251,7 @@ void RouteRenderer::RenderRoute(ScreenBase const & screen, bool trafficShown,
     dp::UniformValuesStorage uniforms = commonUniforms;
     math::Matrix<float, 4, 4> mv = screen.GetModelView(m_routeData->m_pivot, kShapeCoordScalar);
     uniforms.SetMatrix4x4Value("modelView", mv.m_data);
-    glsl::vec4 const color = glsl::ToVec4(df::GetColorConstant(GetStyleReader().GetCurrentStyle(),
-                                                               m_routeData->m_color));
+    glsl::vec4 const color = glsl::ToVec4(df::GetColorConstant(m_routeData->m_color));
     uniforms.SetFloatValue("u_color", color.r, color.g, color.b, color.a);
     double const screenScale = screen.GetScale();
     uniforms.SetFloatValue("u_routeParams", m_currentHalfWidth, m_currentHalfWidth * screenScale,
diff --git a/drape_frontend/route_renderer.hpp b/drape_frontend/route_renderer.hpp
index 330bea92a6..47e08c4e06 100644
--- a/drape_frontend/route_renderer.hpp
+++ b/drape_frontend/route_renderer.hpp
@@ -7,9 +7,16 @@
 
 #include "geometry/screenbase.hpp"
 
+#include <string>
+
 namespace df
 {
 
+extern std::string kRouteColor;
+extern std::string kRouteOutlineColor;
+extern std::string kRoutePedestrian;
+extern std::string kRouteBicycle;
+
 class RouteRenderer final
 {
 public:
diff --git a/drape_frontend/route_shape.cpp b/drape_frontend/route_shape.cpp
index 7438e6ff4e..836586f4c5 100644
--- a/drape_frontend/route_shape.cpp
+++ b/drape_frontend/route_shape.cpp
@@ -425,11 +425,10 @@ void RouteShape::CacheRoute(ref_ptr<dp::TextureManager> textures, RouteData & ro
 {
   vector<glsl::vec4> segmentsColors;
   segmentsColors.reserve(routeData.m_traffic.size());
-  auto const & style = GetStyleReader().GetCurrentStyle();
   for (auto const & speedGroup : routeData.m_traffic)
   {
-    dp::Color const color = df::GetColorConstant(style, TrafficGenerator::GetColorBySpeedGroup(speedGroup,
-                                                        true /* route */));
+    dp::Color const color = df::GetColorConstant(TrafficGenerator::GetColorBySpeedGroup(speedGroup,
+                                                                                        true /* route */));
     float const alpha = (speedGroup == traffic::SpeedGroup::G4 ||
                          speedGroup == traffic::SpeedGroup::G5 ||
                          speedGroup == traffic::SpeedGroup::Unknown) ? 0.0f : 1.0f;
diff --git a/drape_frontend/selection_shape.cpp b/drape_frontend/selection_shape.cpp
index 715cb73460..c539c704f6 100644
--- a/drape_frontend/selection_shape.cpp
+++ b/drape_frontend/selection_shape.cpp
@@ -19,9 +19,9 @@
 
 namespace df
 {
-
 namespace
 {
+df::ColorConstant const kSelectionColor = "Selection";
 
 struct Vertex
 {
@@ -55,8 +55,7 @@ dp::BindingInfo GetBindingInfo()
 
   return info;
 }
-
-} // namespace
+} //  namespace
 
 SelectionShape::SelectionShape(ref_ptr<dp::TextureManager> mng)
   : m_position(m2::PointD::Zero())
@@ -69,7 +68,7 @@ SelectionShape::SelectionShape(ref_ptr<dp::TextureManager> mng)
   float const etalonSector = math::twicePi / static_cast<double>(TriangleCount);
 
   dp::TextureManager::ColorRegion color;
-  mng->GetColorRegion(df::GetColorConstant(GetStyleReader().GetCurrentStyle(), df::Selection), color);
+  mng->GetColorRegion(df::GetColorConstant(df::kSelectionColor), color);
   glsl::vec2 colorCoord = glsl::ToVec2(color.GetTexRect().Center());
 
   buffer_vector<Vertex, TriangleCount> buffer;
diff --git a/drape_frontend/traffic_generator.cpp b/drape_frontend/traffic_generator.cpp
index 61239beb3b..574e626425 100644
--- a/drape_frontend/traffic_generator.cpp
+++ b/drape_frontend/traffic_generator.cpp
@@ -337,26 +337,26 @@ df::ColorConstant TrafficGenerator::GetColorBySpeedGroup(traffic::SpeedGroup con
   size_t constexpr kSpeedGroupsCount = static_cast<size_t>(traffic::SpeedGroup::Count);
   static array<df::ColorConstant, kSpeedGroupsCount> const kColorMap
   {{
-    df::TrafficG0,
-    df::TrafficG1,
-    df::TrafficG2,
-    df::TrafficG3,
-    df::TrafficG4,
-    df::TrafficG5,
-    df::TrafficTempBlock,
-    df::TrafficUnknown,
+    "TrafficG0",
+    "TrafficG1",
+    "TrafficG2",
+    "TrafficG3",
+    "TrafficG4",
+    "TrafficG5",
+    "TrafficTempBlock",
+    "TrafficUnknown",
   }};
 
   static array<df::ColorConstant, kSpeedGroupsCount> const kColorMapRoute
   {{
-    df::RouteTrafficG0,
-    df::RouteTrafficG1,
-    df::RouteTrafficG2,
-    df::RouteTrafficG3,
-    df::TrafficG4,
-    df::TrafficG5,
-    df::TrafficTempBlock,
-    df::TrafficUnknown,
+    "RouteTrafficG0",
+    "RouteTrafficG1",
+    "RouteTrafficG2",
+    "RouteTrafficG3",
+    "TrafficG4",
+    "TrafficG5",
+    "TrafficTempBlock",
+    "TrafficUnknown",
   }};
 
   size_t const index = static_cast<size_t>(speedGroup);
@@ -369,12 +369,11 @@ void TrafficGenerator::FillColorsCache(ref_ptr<dp::TextureManager> textures)
   size_t constexpr kSpeedGroupsCount = static_cast<size_t>(traffic::SpeedGroup::Count);
   if (!m_colorsCacheValid)
   {
-    auto const & style = GetStyleReader().GetCurrentStyle();
     for (size_t i = 0; i < kSpeedGroupsCount; i++)
     {
       dp::TextureManager::ColorRegion colorRegion;
       auto const colorConstant = GetColorBySpeedGroup(static_cast<traffic::SpeedGroup>(i), false /* route */);
-      textures->GetColorRegion(df::GetColorConstant(style, colorConstant), colorRegion);
+      textures->GetColorRegion(df::GetColorConstant(colorConstant), colorRegion);
       m_colorsCache[i] = colorRegion;
     }
     m_colorsCacheValid = true;
diff --git a/drape_frontend/traffic_renderer.cpp b/drape_frontend/traffic_renderer.cpp
index 139d8ba5d9..8265bc8f11 100644
--- a/drape_frontend/traffic_renderer.cpp
+++ b/drape_frontend/traffic_renderer.cpp
@@ -16,9 +16,11 @@
 
 namespace df
 {
-
 namespace
 {
+df::ColorConstant const kTrafficArrowLightColor = "TrafficArrowLight";
+df::ColorConstant const kTrafficArrowDarkColor = "TrafficArrowDark";
+df::ColorConstant const kTrafficOutlineColor = "TrafficOutline";
 
 int constexpr kMinVisibleArrowZoomLevel = 16;
 int constexpr kRoadClass2MinVisibleArrowZoomLevel = 17;
@@ -100,8 +102,7 @@ float CalculateHalfWidth(ScreenBase const & screen, RoadClass const & roadClass,
 
   return radius * VisualParams::Instance().GetVisualScale();
 }
-
-} // namespace
+} //  namespace
 
 void TrafficRenderer::AddRenderData(ref_ptr<dp::GpuProgramManager> mng, TrafficRenderData && renderData)
 {
@@ -150,10 +151,9 @@ void TrafficRenderer::RenderTraffic(ScreenBase const & screen, int zoomLevel, fl
   if (m_renderData.empty() || zoomLevel < kRoadClass0ZoomLevel)
     return;
 
-  auto const style = GetStyleReader().GetCurrentStyle();
-  dp::Color const lightArrowColor = df::GetColorConstant(style, df::TrafficArrowLight);
-  dp::Color const darkArrowColor = df::GetColorConstant(style, df::TrafficArrowDark);
-  dp::Color const outlineColor = df::GetColorConstant(style, df::TrafficOutline);
+  dp::Color const lightArrowColor = df::GetColorConstant(df::kTrafficArrowLightColor);
+  dp::Color const darkArrowColor = df::GetColorConstant(df::kTrafficArrowDarkColor);
+  dp::Color const outlineColor = df::GetColorConstant(df::kTrafficOutlineColor);
 
   for (TrafficRenderData & renderData : m_renderData)
   {
diff --git a/indexer/drawing_rules.cpp b/indexer/drawing_rules.cpp
index 2a8d66dd9e..52e57b5ebc 100644
--- a/indexer/drawing_rules.cpp
+++ b/indexer/drawing_rules.cpp
@@ -132,6 +132,7 @@ void RulesHolder::Clean()
   }
 
   m_rules.clear();
+  m_colors.clear();
 }
 
 Key RulesHolder::AddRule(int scale, rule_type_t type, BaseRule * p)
@@ -166,11 +167,22 @@ BaseRule const * RulesHolder::Find(Key const & k) const
 
 uint32_t RulesHolder::GetBgColor(int scale) const
 {
-  ASSERT_LESS(scale, m_bgColors.size(), ());
+  ASSERT_LESS(scale, static_cast<int>(m_bgColors.size()), ());
   ASSERT_GREATER_OR_EQUAL(scale, 0, ());
   return m_bgColors[scale];
 }
 
+uint32_t RulesHolder::GetColor(std::string const & name) const
+{
+  auto it = m_colors.find(name);
+  if (it == m_colors.end())
+  {
+    LOG(LWARNING, ("Requested color '" + name + "' is not found"));
+    return 0;
+  }
+  return it->second;
+}
+
 void RulesHolder::ClearCaches()
 {
   ForEachRule(bind(static_cast<void (BaseRule::*)()>(&BaseRule::MakeEmptyID), _4));
@@ -496,6 +508,19 @@ void RulesHolder::InitBackgroundColors(ContainerProto const & cont)
   }
 }
 
+void RulesHolder::InitColors(ContainerProto const & cp)
+{
+  if (!cp.has_colors())
+    return;
+
+  ASSERT_EQUAL(m_colors.size(), 0, ());
+  for (int i = 0; i < cp.colors().value_size(); i++)
+  {
+    ColorElementProto const & proto = cp.colors().value(i);
+    m_colors.insert(std::make_pair(proto.name(), proto.color()));
+  }
+}
+
 void RulesHolder::LoadFromBinaryProto(string const & s)
 {
   Clean();
@@ -507,6 +532,7 @@ void RulesHolder::LoadFromBinaryProto(string const & s)
   classif().GetMutableRoot()->ForEachObject(ref(doSet));
 
   InitBackgroundColors(doSet.m_cont);
+  InitColors(doSet.m_cont);
 }
 
 void LoadRules()
diff --git a/indexer/drawing_rules.hpp b/indexer/drawing_rules.hpp
index 317e971ed5..a2f941dfcb 100644
--- a/indexer/drawing_rules.hpp
+++ b/indexer/drawing_rules.hpp
@@ -14,6 +14,7 @@
 #include "std/iostream.hpp"
 #include "std/target_os.hpp"
 
+#include <unordered_map>
 
 class LineDefProto;
 class AreaRuleProto;
@@ -78,6 +79,8 @@ namespace drule
     /// background color for scales in range [0...scales::UPPER_STYLE_SCALE]
     vector<uint32_t> m_bgColors;
 
+    std::unordered_map<std::string, uint32_t> m_colors;
+
   public:
     RulesHolder();
     ~RulesHolder();
@@ -92,6 +95,7 @@ namespace drule
     BaseRule const * Find(Key const & k) const;
 
     uint32_t GetBgColor(int scale) const;
+    uint32_t GetColor(std::string const & name) const;
 
 #ifdef OMIM_OS_DESKTOP
     void LoadFromTextProto(string const & buffer);
@@ -118,6 +122,7 @@ namespace drule
 
   private:
     void InitBackgroundColors(ContainerProto const & cp);
+    void InitColors(ContainerProto const & cp);
   };
 
   RulesHolder & rules();
diff --git a/map/framework.cpp b/map/framework.cpp
index 5918202296..ed2f26ce70 100644
--- a/map/framework.cpp
+++ b/map/framework.cpp
@@ -34,6 +34,7 @@
 
 #include "drape_frontend/color_constants.hpp"
 #include "drape_frontend/gps_track_point.hpp"
+#include "drape_frontend/route_renderer.hpp"
 #include "drape_frontend/visual_params.hpp"
 #include "drape_frontend/watch/cpu_drawer.hpp"
 #include "drape_frontend/watch/feature_processor.hpp"
@@ -2539,16 +2540,16 @@ void Framework::InsertRoute(Route const & route)
     route.GetTurnsDistances(turns);
   }
 
-  df::ColorConstant routeColor = df::Route;
+  df::ColorConstant routeColor = df::kRouteColor;
   df::RoutePattern pattern;
   if (m_currentRouterType == RouterType::Pedestrian)
   {
-    routeColor = df::RoutePedestrian;
+    routeColor = df::kRoutePedestrian;
     pattern = df::RoutePattern(4.0, 2.0);
   }
   else if (m_currentRouterType == RouterType::Bicycle)
   {
-    routeColor = df::RouteBicycle;
+    routeColor = df::kRouteBicycle;
     pattern = df::RoutePattern(8.0, 2.0);
   }