[drape] build android with drape

36 files changed, 1240 insertions, 1863 deletions

diff --git a/map/address_finder.cpp b/map/address_finder.cpp
index 07c6950292..8d340122c6 100644
--- a/map/address_finder.cpp
+++ b/map/address_finder.cpp
@@ -1,6 +1,7 @@
 #include "map/framework.hpp"
 
 #include "search/result.hpp"
+#include "drape_frontend/visual_params.hpp"
 
 #include "indexer/classificator.hpp"
 #include "indexer/feature_visibility.hpp"
@@ -164,7 +165,7 @@ namespace
 void Framework::GetFeatureTypes(m2::PointD const & pxPoint, vector<string> & types) const
 {
   m2::AnyRectD rect;
-  m_navigator.GetTouchRect(pxPoint, TOUCH_PIXEL_RADIUS * GetVisualScale(), rect);
+  m_navigator.GetTouchRect(pxPoint, TOUCH_PIXEL_RADIUS * df::VisualParams::Instance().GetVisualScale(), rect);
 
   // This scale should fit in geometry scales range.
   int const scale = min(GetDrawScale(), scales::GetUpperScale());
diff --git a/map/alfa_animation_task.cpp b/map/alfa_animation_task.cpp
index 5a65277a7b..b9450f06b0 100644
--- a/map/alfa_animation_task.cpp
+++ b/map/alfa_animation_task.cpp
@@ -28,7 +28,8 @@ void AlfaAnimationTask::OnStart(double ts)
 {
   m_timeStart = ts;
   BaseT::OnStart(ts);
-  m_f->Invalidate();
+  ///@TODO UVR
+  //m_f->Invalidate();
 }
 
 void AlfaAnimationTask::OnStep(double ts)
@@ -48,5 +49,6 @@ void AlfaAnimationTask::OnStep(double ts)
       m_current = m_start + t * (m_end - m_start);
   }
 
-  m_f->Invalidate();
+  ///@TODO UVR
+  //m_f->Invalidate();
 }
diff --git a/map/anim_phase_chain.cpp b/map/anim_phase_chain.cpp
index 5915ce82cf..a6b6661d53 100644
--- a/map/anim_phase_chain.cpp
+++ b/map/anim_phase_chain.cpp
@@ -49,7 +49,8 @@ void AnimPhaseChain::OnStep(double ts)
   double t = elapsedTime / phase->m_timeInterval;
   m_scale = m_startScale + t * (phase->m_endScale - m_startScale);
 
-  m_f.Invalidate();
+  ///@TODO UVR
+  //m_f.Invalidate();
 }
 
 void InitDefaultPinAnim(AnimPhaseChain * chain)
diff --git a/map/bookmark.cpp b/map/bookmark.cpp
index ca2395f4c9..d635db1570 100644
--- a/map/bookmark.cpp
+++ b/map/bookmark.cpp
@@ -8,6 +8,7 @@
 
 #include "base/scope_guard.hpp"
 
+
 #include "graphics/depth_constants.hpp"
 
 #include "indexer/mercator.hpp"
@@ -17,6 +18,9 @@
 #include "coding/internal/file_data.hpp"
 #include "coding/hex.hpp"
 
+#include "drape/drape_global.hpp"
+#include "drape/color.hpp"
+
 #include "platform/platform.hpp"
 
 #include "base/stl_add.hpp"
@@ -31,6 +35,23 @@ unique_ptr<UserMarkCopy> Bookmark::Copy() const
   return unique_ptr<UserMarkCopy>(new UserMarkCopy(this, false));
 }
 
+///@TODO UVR
+//graphics::DisplayList * Bookmark::GetDisplayList(UserMarkDLCache * cache) const
+//{
+//  return cache->FindUserMark(UserMarkDLCache::Key(GetType(), dp::Bottom, GetContainer()->GetDepth()));
+//}
+
+double Bookmark::GetAnimScaleFactor() const
+{
+  return m_animScaleFactor;
+}
+
+m2::PointD const & Bookmark::GetPixelOffset() const
+{
+  static m2::PointD s_offset(0.0, 3.0);
+  return s_offset;
+}
+
 shared_ptr<anim::Task> Bookmark::CreateAnimTask(Framework & fm)
 {
   m_animScaleFactor = 0.0;
@@ -73,7 +94,7 @@ void BookmarkCategory::ReplaceBookmark(size_t index, BookmarkData const & bm)
 }
 
 BookmarkCategory::BookmarkCategory(const string & name, Framework & framework)
-  : base_t(graphics::bookmarkDepth, framework)
+  : base_t(0.0/*graphics::bookmarkDepth*/, framework)
   , m_name(name)
   , m_blockAnimation(false)
 {
@@ -166,14 +187,14 @@ size_t BookmarkCategory::FindBookmark(Bookmark const * bookmark) const
 
 namespace
 {
-string const kPlacemark = "Placemark";
-string const kStyle = "Style";
-string const kDocument = "Document";
-string const kStyleMap = "StyleMap";
-string const kStyleUrl = "styleUrl";
-string const kPair = "Pair";
+  string const kPlacemark = "Placemark";
+  string const kStyle = "Style";
+  string const kDocument = "Document";
+  string const kStyleMap = "StyleMap";
+  string const kStyleUrl = "styleUrl";
+  string const kPair = "Pair";
 
-graphics::Color const kDefaultTrackColor = graphics::Color::fromARGB(0xFF33CCFF);
+  dp::Color const kDefaultTrackColor = dp::Extract(0xFF33CCFF);
 
   string PointToString(m2::PointD const & org)
   {
@@ -210,12 +231,12 @@ graphics::Color const kDefaultTrackColor = graphics::Color::fromARGB(0xFF33CCFF)
     vector<string> m_tags;
     GeometryType m_geometryType;
     m2::PolylineD m_points;
-    graphics::Color m_trackColor;
+    dp::Color m_trackColor;
 
     string m_styleId;
     string m_mapStyleId;
     string m_styleUrlKey;
-    map<string, graphics::Color> m_styleUrl2Color;
+    map<string, dp::Color> m_styleUrl2Color;
     map<string, string> m_mapStyle2Style;
 
     string m_name;
@@ -322,10 +343,10 @@ graphics::Color const kDefaultTrackColor = graphics::Color::fromARGB(0xFF33CCFF)
       string fromHex = FromHex(value);
       ASSERT(fromHex.size() == 4, ("Invalid color passed"));
       // Color positions in HEX – aabbggrr
-      m_trackColor = graphics::Color(fromHex[3], fromHex[2], fromHex[1], fromHex[0]);
+      m_trackColor = dp::Color(fromHex[3], fromHex[2], fromHex[1], fromHex[0]);
     }
 
-    bool GetColorForStyle(string const & styleUrl, graphics::Color & color)
+    bool GetColorForStyle(string const & styleUrl, dp::Color & color)
     {
       if (styleUrl.empty())
         return false;
@@ -751,12 +772,12 @@ void BookmarkCategory::SaveToKML(ostream & s)
     s << "</name>\n";
 
     s << "<Style><LineStyle>";
-    graphics::Color const & col = track->GetMainColor();
+    dp::Color const & col = track->GetMainColor();
     s << "<color>"
-      << NumToHex(col.a)
-      << NumToHex(col.b)
-      << NumToHex(col.g)
-      << NumToHex(col.r);
+      << NumToHex(col.GetAlfa())
+      << NumToHex(col.GetBlue())
+      << NumToHex(col.GetGreen())
+      << NumToHex(col.GetRed());
     s << "</color>\n";
 
     s << "<width>"
diff --git a/map/bookmark.hpp b/map/bookmark.hpp
index e5e08afb21..fab0f6e4a9 100644
--- a/map/bookmark.hpp
+++ b/map/bookmark.hpp
@@ -110,6 +110,9 @@ public:
 
   unique_ptr<UserMarkCopy> Copy() const override;
 
+  //virtual graphics::DisplayList * GetDisplayList(UserMarkDLCache * cache) const;
+  virtual double GetAnimScaleFactor() const;
+  virtual m2::PointD const & GetPixelOffset() const;
   shared_ptr<anim::Task> CreateAnimTask(Framework & fm);
 
   // StyledPoint overrides:
diff --git a/map/bookmark_manager.cpp b/map/bookmark_manager.cpp
index 398198564f..d86f9091dd 100644
--- a/map/bookmark_manager.cpp
+++ b/map/bookmark_manager.cpp
@@ -19,19 +19,18 @@
 #include "std/target_os.hpp"
 #include "std/vector.hpp"
 
-
 BookmarkManager::BookmarkManager(Framework & f)
   : m_framework(f)
-  , m_bmScreen(0)
   , m_lastScale(1.0)
   , m_cache(NULL)
   , m_selection(f)
   , m_routeRenderer(new rg::RouteRenderer())
 {
   m_userMarkLayers.reserve(3);
-  m_userMarkLayers.push_back(new SearchUserMarkContainer(graphics::activePinDepth, m_framework));
-  m_userMarkLayers.push_back(new ApiUserMarkContainer(graphics::activePinDepth, m_framework));
-  m_userMarkLayers.push_back(new DebugUserMarkContainer(graphics::debugDepth, m_framework));
+  ///@TODO UVR
+  m_userMarkLayers.push_back(new SearchUserMarkContainer(0.0/*graphics::activePinDepth*/, m_framework));
+  m_userMarkLayers.push_back(new ApiUserMarkContainer(0.0/*graphics::activePinDepth*/, m_framework));
+  //m_userMarkLayers.push_back(new DebugUserMarkContainer(graphics::debugDepth, m_framework));
   UserMarkContainer::InitStaticMarks(FindUserMarksContainer(UserMarkContainer::SEARCH_MARK));
 }
 
@@ -137,29 +136,30 @@ void BookmarkManager::PrepareToShutdown()
 
 void BookmarkManager::DrawCategory(BookmarkCategory const * cat, PaintOverlayEvent const & e) const
 {
-#ifndef USE_DRAPE
-  /// TODO cutomize draw in UserMarkContainer for user Draw method
-  ASSERT(cat, ());
-  if (!cat->IsVisible())
-    return;
-
-  Navigator const & navigator = m_framework.GetNavigator();
-  ScreenBase const & screen = navigator.Screen();
+///@TODO UVR
+//#ifndef USE_DRAPE
+//  /// TODO cutomize draw in UserMarkContainer for user Draw method
+//  ASSERT(cat, ());
+//  if (!cat->IsVisible())
+//    return;
+//  Navigator const & navigator = m_framework.GetNavigator();
+//  ScreenBase const & screen = navigator.Screen();
 
-  graphics::Screen * pScreen = GPUDrawer::GetScreen(e.GetDrawer());
+//  Drawer * pDrawer = e.GetDrawer();
+//  graphics::Screen * pScreen = pDrawer->screen();
 
-  LazyMatrixCalc matrix(screen, m_lastScale);
+//  LazyMatrixCalc matrix(screen, m_lastScale);
 
-  // Draw tracks.
-  for (size_t i = 0; i < cat->GetTracksCount(); ++i)
-  {
-    Track const * track = cat->GetTrack(i);
-    if (track->HasDisplayLists())
-      track->Draw(pScreen, matrix.GetFinalG2P());
-  }
+//  // Draw tracks.
+//  for (size_t i = 0; i < cat->GetTracksCount(); ++i)
+//  {
+//    Track const * track = cat->GetTrack(i);
+//    if (track->HasDisplayList())
+//      track->Draw(pScreen, matrix.GetFinalG2P());
+//  }
 
-  cat->Draw(e, m_cache);
-#endif // USE_DRAPE
+//  cat->Draw(e, m_cache);
+//#endif // USE_DRAPE
 }
 
 void BookmarkManager::ClearItems()
@@ -262,62 +262,60 @@ size_t BookmarkManager::CreateBmCategory(string const & name)
 
 void BookmarkManager::DrawItems(Drawer * drawer) const
 {
-#ifndef USE_DRAPE
-  ASSERT(m_cache != NULL, ());
-  ASSERT(m_framework.GetLocationState(), ());
-
-  ScreenBase const & screen = m_framework.GetNavigator().Screen();
-  m2::RectD const limitRect = screen.ClipRect();
-
-  LazyMatrixCalc matrix(screen, m_lastScale);
-
-  double const drawScale = m_framework.GetDrawScale();
-  double const visualScale = m_framework.GetVisualScale();
-  location::RouteMatchingInfo const & matchingInfo = m_framework.GetLocationState()->GetRouteMatchingInfo();
-
-  auto trackUpdateFn = [&](Track const * track)
-  {
-    ASSERT(track, ());
-    if (limitRect.IsIntersect(track->GetLimitRect()))
-      track->CreateDisplayList(m_bmScreen, matrix.GetScaleG2P(), matrix.IsScaleChanged(), drawScale, visualScale, matchingInfo);
-    else
-      track->CleanUp();
-  };
-
-  auto dlUpdateFn = [&trackUpdateFn] (BookmarkCategory const * cat)
-  {
-    bool const isVisible = cat->IsVisible();
-    for (size_t j = 0; j < cat->GetTracksCount(); ++j)
-    {
-      Track const * track = cat->GetTrack(j);
-      ASSERT(track, ());
-      if (isVisible)
-        trackUpdateFn(track);
-      else
-        track->CleanUp();
-    }
-  };
+  //@TODO UVR
+  //ASSERT(m_cache != NULL, ());
+  //ASSERT(m_framework.GetLocationState(), ());
+
+  //ScreenBase const & screen = m_framework.GetNavigator().Screen();
+  //m2::RectD const limitRect = screen.ClipRect();
+
+  //LazyMatrixCalc matrix(screen, m_lastScale);
+
+  //double const drawScale = m_framework.GetDrawScale();
+  //double const visualScale = m_framework.GetVisualScale();
+  //location::RouteMatchingInfo const & matchingInfo = m_framework.GetLocationState()->GetRouteMatchingInfo();
+
+  //auto trackUpdateFn = [&](Track const * track)
+  //{
+  //  ASSERT(track, ());
+  //  if (limitRect.IsIntersect(track->GetLimitRect()))
+  //    track->CreateDisplayList(m_bmScreen, matrix.GetScaleG2P(), matrix.IsScaleChanged(), drawScale, visualScale, matchingInfo);
+  //  else
+  //    track->CleanUp();
+  //};
+
+  //auto dlUpdateFn = [&trackUpdateFn] (BookmarkCategory const * cat)
+  //{
+  //  bool const isVisible = cat->IsVisible();
+  //  for (size_t j = 0; j < cat->GetTracksCount(); ++j)
+  //  {
+  //    Track const * track = cat->GetTrack(j);
+  //    ASSERT(track, ());
+  //    if (isVisible)
+  //      trackUpdateFn(track);
+  //    else
+  //      track->CleanUp();
+  //  }
+  //};
 
   // Update track's display lists.
-  for (size_t i = 0; i < m_categories.size(); ++i)
-  {
-    BookmarkCategory const * cat = m_categories[i];
-    ASSERT(cat, ());
-    dlUpdateFn(cat);
-  }
-
-  graphics::Screen * pScreen = GPUDrawer::GetScreen(drawer);
-  pScreen->beginFrame();
-
-  PaintOverlayEvent event(drawer, screen);
-  for (auto const & layer : m_userMarkLayers)
-    layer->Draw(event, m_cache);
-  for (auto const & category : m_categories)
-    DrawCategory(category, event);
-  m_routeRenderer->Render(pScreen, screen);
-  m_selection.Draw(event, m_cache);
-
-  pScreen->endFrame();
+  //for (size_t i = 0; i < m_categories.size(); ++i)
+  //{
+  //  BookmarkCategory const * cat = m_categories[i];
+  //  ASSERT(cat, ());
+  //  dlUpdateFn(cat);
+  //}
+
+  //graphics::Screen * pScreen = GPUDrawer::GetScreen(drawer);
+  //pScreen->beginFrame();
+
+  //PaintOverlayEvent event(drawer, screen);
+  //for_each(m_userMarkLayers.begin(), m_userMarkLayers.end(), bind(&UserMarkContainer::Draw, _1, event, m_cache));
+  //for_each(m_categories.begin(), m_categories.end(), bind(&BookmarkManager::DrawCategory, this, _1, event));
+  //m_routeRenderer->Render(pScreen, screen);
+  //m_selection.Draw(event, m_cache);
+
+  //pScreen->endFrame();
 #endif // USE_DRAPE
 }
 
@@ -444,30 +442,33 @@ UserMarkContainer::Controller & BookmarkManager::UserMarksGetController(UserMark
   return FindUserMarksContainer(type)->GetController();
 }
 
-void BookmarkManager::SetScreen(graphics::Screen * screen)
-{
-  ResetScreen();
-  m_bmScreen = screen;
-  m_cache = new UserMarkDLCache(m_bmScreen);
-}
+///@TODO UVR
+//void BookmarkManager::SetScreen(graphics::Screen * screen)
+//{
+//  ResetScreen();
+//  m_bmScreen = screen;
+//  m_cache = new UserMarkDLCache(m_bmScreen);
+//}
 
 void BookmarkManager::ResetScreen()
 {
-  delete m_cache;
-  m_cache = NULL;
+  ///@TODO UVR
+  //delete m_cache;
+  //m_cache = NULL;
 
-  auto dlDeleteFn = [] (BookmarkCategory const * cat)
-  {
-    for (size_t j = 0; j < cat->GetTracksCount(); ++j)
-      cat->GetTrack(j)->CleanUp();
-  };
+  //auto dlDeleteFn = [] (BookmarkCategory const * cat)
+  //{
+  //  for (size_t j = 0; j < cat->GetTracksCount(); ++j)
+  //    cat->GetTrack(j)->CleanUp();
+  //};
 
-  if (m_bmScreen)
-  {
+  //if (m_bmScreen)
+  //{
     // Delete display lists for all tracks
-    for_each(m_categories.begin(), m_categories.end(), dlDeleteFn);
-    m_bmScreen = 0;
-  }
+  //  for_each(m_categories.begin(), m_categories.end(), dlDeleteFn);
+  //  m_routeRenderer->Clear();
+  //  m_bmScreen = 0;
+  //}
 }
 
 void BookmarkManager::SetRouteTrack(m2::PolylineD const & routePolyline, vector<double> const & turns,
diff --git a/map/bookmark_manager.hpp b/map/bookmark_manager.hpp
index 58fe372815..9e4ceebe76 100644
--- a/map/bookmark_manager.hpp
+++ b/map/bookmark_manager.hpp
@@ -10,8 +10,6 @@
 
 class Framework;
 class PaintEvent;
-namespace graphics { class Screen; }
-namespace rg { class RouteRenderer; }
 
 class BookmarkManager : private noncopyable
 {
@@ -23,7 +21,6 @@ class BookmarkManager : private noncopyable
 
   vector<UserMarkContainer * > m_userMarkLayers;
 
-  graphics::Screen * m_bmScreen;
   mutable double m_lastScale;
 
   typedef vector<BookmarkCategory *>::iterator CategoryIter;
@@ -85,7 +82,8 @@ public:
   void UserMarksClear(UserMarkContainer::Type type, size_t skipCount = 0);
   UserMarkContainer::Controller & UserMarksGetController(UserMarkContainer::Type type);
 
-  void SetScreen(graphics::Screen * screen);
+  ///@TODO UVR
+  //void SetScreen(graphics::Screen * screen);
   void ResetScreen();
 
   void SetRouteTrack(m2::PolylineD const & routePolyline, vector<double> const & turns,
diff --git a/map/compass_arrow.cpp b/map/compass_arrow.cpp
index d0beff1250..7f1ca34338 100644
--- a/map/compass_arrow.cpp
+++ b/map/compass_arrow.cpp
@@ -19,27 +19,27 @@ CompassArrow::Params::Params()
 {}
 
 CompassArrow::CompassArrow(Params const & p)
-  : BaseT(p),
-    m_pixelSize(-1, -1),
-    m_angle(0),
+  : m_angle(0),
     m_framework(p.m_framework)
 {
 }
 
 void CompassArrow::AnimateShow()
 {
-  if (!isVisible())
-  {
-    setIsVisible(true);
-    double startValue = m_animTask == nullptr ? 0.1 : GetCurrentAlfa();
-    CreateAnim(startValue, 1.0, 0.2, 0.0, true);
-  }
+  ///@TODO UVR
+//  if (!isVisible())
+//  {
+//    setIsVisible(true);
+//    double startValue = m_animTask == nullptr ? 0.1 : GetCurrentAlfa();
+//    CreateAnim(startValue, 1.0, 0.2, 0.0, true);
+//  }
 }
 
 void CompassArrow::AnimateHide()
 {
-  if (isBaseVisible() && (m_animTask == NULL || !IsHidingAnim()))
-    CreateAnim(1.0, 0.0, 0.3, 0.0, false);
+  ///@TODO UVR
+//  if (isBaseVisible() && (m_animTask == NULL || !IsHidingAnim()))
+//    CreateAnim(1.0, 0.0, 0.3, 0.0, false);
 }
 
 void CompassArrow::SetAngle(double angle)
@@ -47,44 +47,26 @@ void CompassArrow::SetAngle(double angle)
   m_angle = angle;
 }
 
-m2::PointI CompassArrow::GetPixelSize() const
-{
-  if (m_pixelSize == m2::PointI(-1, -1))
-  {
-    Resource const * res = GetCompassResource();
-    m_pixelSize = m2::PointI(res->m_texRect.SizeX(), res->m_texRect.SizeY());
-  }
-  return m_pixelSize;
-}
+///@TODO UVR
+//void CompassArrow::draw(OverlayRenderer * r,
+//                        math::Matrix<double, 3, 3> const & m) const
+//{
+//  if (isBaseVisible())
+//  {
+//    checkDirtyLayout();
 
-void CompassArrow::GetMiniBoundRects(RectsT & rects) const
-{
-  double const halfW = m_pixelSize.x / 2.0;
-  double const halfH = m_pixelSize.y / 2.0;
+//    UniformsHolder holder;
+//    holder.insertValue(ETransparency, GetCurrentAlfa());
 
-  rects.push_back(m2::AnyRectD(pivot(), -math::pi / 2 + m_angle,
-                               m2::RectD(-halfW, -halfH, halfW, halfH)));
-}
+//    math::Matrix<double, 3, 3> drawM = math::Shift(
+//                                         math::Rotate(
+//                                           math::Identity<double, 3>(),
+//                                           m_angle),
+//                                         pivot());
 
-void CompassArrow::draw(OverlayRenderer * r,
-                        math::Matrix<double, 3, 3> const & m) const
-{
-  if (isBaseVisible())
-  {
-    checkDirtyLayout();
-
-    UniformsHolder holder;
-    holder.insertValue(ETransparency, GetCurrentAlfa());
-
-    math::Matrix<double, 3, 3> drawM = math::Shift(
-                                         math::Rotate(
-                                           math::Identity<double, 3>(),
-                                           m_angle),
-                                         pivot());
-
-    r->drawDisplayList(m_dl.get(), drawM * m, &holder);
-  }
-}
+//    r->drawDisplayList(m_dl.get(), drawM * m, &holder);
+//  }
+//}
 
 bool CompassArrow::isVisible() const
 {
@@ -96,7 +78,8 @@ bool CompassArrow::isVisible() const
 
 void CompassArrow::AlfaAnimEnded(bool isVisible)
 {
-  setIsVisible(isVisible);
+  ///@TODO UVR
+  //setIsVisible(isVisible);
   m_animTask.reset();
 }
 
@@ -131,84 +114,57 @@ void CompassArrow::CreateAnim(double startAlfa, double endAlfa, double timeInter
   m_framework->GetAnimController()->AddTask(m_animTask);
 }
 
-const Resource * CompassArrow::GetCompassResource() const
-{
-  Screen * cacheScreen = m_controller->GetCacheScreen();
-  Icon::Info icon("compass-image");
-  Resource const * res = m_controller->GetCacheScreen()->fromID(cacheScreen->findInfo(icon));
-  ASSERT(res, ("Commpass-image not founded"));
-  return res;
-}
-
 void CompassArrow::cache()
 {
-  Screen * cacheScreen = m_controller->GetCacheScreen();
+  ///@TODO UVR
+//  Screen * cacheScreen = m_controller->GetCacheScreen();
 
-  m_dl.reset();
-  m_dl.reset(cacheScreen->createDisplayList());
+//  m_dl.reset();
+//  m_dl.reset(cacheScreen->createDisplayList());
 
-  cacheScreen->beginFrame();
-  cacheScreen->setDisplayList(m_dl.get());
-  cacheScreen->applyVarAlfaStates();
+//  cacheScreen->beginFrame();
+//  cacheScreen->setDisplayList(m_dl.get());
+//  cacheScreen->applyVarAlfaStates();
 
-  Resource const * res = GetCompassResource();
-  shared_ptr<gl::BaseTexture> texture = cacheScreen->pipeline(res->m_pipelineID).texture();
-  m2::RectU rect = res->m_texRect;
-  double halfW = rect.SizeX() / 2.0;
-  double halfH = rect.SizeY() / 2.0;
+//  Resource const * res = GetCompassResource();
+//  shared_ptr<gl::BaseTexture> texture = cacheScreen->pipeline(res->m_pipelineID).texture();
+//  m2::RectU rect = res->m_texRect;
+//  double halfW = rect.SizeX() / 2.0;
+//  double halfH = rect.SizeY() / 2.0;
 
-  m2::PointD coords[] =
-  {
-    m2::PointD(-halfW, -halfH),
-    m2::PointD(-halfW, halfH),
-    m2::PointD(halfW, -halfH),
-    m2::PointD(halfW, halfH),
-  };
-
-  m2::PointF normal(0.0, 0.0);
-  m2::PointF texCoords[] =
-  {
-    texture->mapPixel(m2::PointF(rect.minX(), rect.minY())),
-    texture->mapPixel(m2::PointF(rect.minX(), rect.maxY())),
-    texture->mapPixel(m2::PointF(rect.maxX(), rect.minY())),
-    texture->mapPixel(m2::PointF(rect.maxX(), rect.maxY())),
-  };
+//  m2::PointD coords[] =
+//  {
+//    m2::PointD(-halfW, -halfH),
+//    m2::PointD(-halfW, halfH),
+//    m2::PointD(halfW, -halfH),
+//    m2::PointD(halfW, halfH),
+//  };
+
+//  m2::PointF normal(0.0, 0.0);
+//  m2::PointF texCoords[] =
+//  {
+//    texture->mapPixel(m2::PointF(rect.minX(), rect.minY())),
+//    texture->mapPixel(m2::PointF(rect.minX(), rect.maxY())),
+//    texture->mapPixel(m2::PointF(rect.maxX(), rect.minY())),
+//    texture->mapPixel(m2::PointF(rect.maxX(), rect.maxY())),
+//  };
 
-  cacheScreen->addTexturedStripStrided(coords, sizeof(m2::PointD),
-                                       &normal, 0,
-                                       texCoords, sizeof(m2::PointF),
-                                       4, depth(), res->m_pipelineID);
+//  cacheScreen->addTexturedStripStrided(coords, sizeof(m2::PointD),
+//                                       &normal, 0,
+//                                       texCoords, sizeof(m2::PointF),
+//                                       4, depth(), res->m_pipelineID);
 
 
-  cacheScreen->setDisplayList(0);
-  cacheScreen->endFrame();
+//  cacheScreen->setDisplayList(0);
+//  cacheScreen->endFrame();
 }
 
 void CompassArrow::purge()
 {
-  m_dl.reset();
 }
 
 bool CompassArrow::isBaseVisible() const
 {
-  return BaseT::isVisible();
-}
-
-bool CompassArrow::onTapEnded(m2::PointD const & pt)
-{
-  anim::Controller * animController = m_framework->GetAnimController();
-  anim::Controller::Guard guard(animController);
-
-  // switching off compass follow mode
-  m_framework->GetLocationState()->OnCompassTaped();
-  m_framework->Invalidate();
-
-  return true;
-}
-
-bool CompassArrow::hitTest(m2::PointD const & pt) const
-{
-  Resource const * res = GetCompassResource();
-  double rad = 1.5 * max(res->m_texRect.SizeX() / 2.0, res->m_texRect.SizeY() / 2.0);
-  return pt.Length(pivot()) < rad * visualScale();
+  ///@TODO UVR
+  return false;
 }
diff --git a/map/compass_arrow.hpp b/map/compass_arrow.hpp
index fa9dd13adb..30bb787bbb 100644
--- a/map/compass_arrow.hpp
+++ b/map/compass_arrow.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "gui/element.hpp"
-
 #include "std/shared_ptr.hpp"
 #include "std/unique_ptr.hpp"
 
@@ -11,25 +9,13 @@ namespace anim
   class Task;
 }
 
-namespace graphics
-{
-  class DisplayList;
-  struct Resource;
-}
-
 class Framework;
 
 /// Compass Arrow, which shows up when the screen is rotated,
 /// and rotates screen back to straight orientation when beeing pressed
-class CompassArrow : public gui::Element
+class CompassArrow
 {
-  typedef gui::Element BaseT;
-
-  mutable m2::PointI m_pixelSize;
   double m_angle;
-
-  unique_ptr<graphics::DisplayList> m_dl;
-
   shared_ptr<anim::Task> m_animTask;
 
   void AlfaAnimEnded(bool isVisible);
@@ -38,12 +24,10 @@ class CompassArrow : public gui::Element
   void CreateAnim(double startAlfa, double endAlfa, double timeInterval, double timeOffset, bool isVisibleAtEnd);
 
   Framework * m_framework;
-  graphics::Resource const * GetCompassResource() const;
-
   bool isBaseVisible() const;
 
 public:
-  struct Params : public BaseT::Params
+  struct Params
   {
     Framework * m_framework;
     Params();
@@ -55,19 +39,16 @@ public:
   void AnimateHide();
 
   void SetAngle(double angle);
-  m2::PointI GetPixelSize() const;
 
   /// @name Override from graphics::Overlayelement and gui::Element.
   //@{
-  virtual void GetMiniBoundRects(RectsT & rects) const;
 
-  void draw(graphics::OverlayRenderer * r, math::Matrix<double, 3, 3> const & m) const;
   bool isVisible() const;
-  bool hitTest(m2::PointD const & pt) const;
+  //bool hitTest(m2::PointD const & pt) const;
 
   void cache();
   void purge();
 
-  bool onTapEnded(m2::PointD const & pt);
+  //bool onTapEnded(m2::PointD const & pt);
   //@}
 };
diff --git a/map/country_status_display.hpp b/map/country_status_display.hpp
index 4047e9cc89..cfe993325e 100644
--- a/map/country_status_display.hpp
+++ b/map/country_status_display.hpp
@@ -2,34 +2,21 @@
 
 #include "map/active_maps_layout.hpp"
 
-#include "gui/element.hpp"
-#include "platform/country_defines.hpp"
-
-#ifdef OMIM_OS_ANDROID
-  #include "../base/mutex.hpp"
-#endif
+#include "storage/storage_defines.hpp"
 
 #include "std/unique_ptr.hpp"
 #include "std/target_os.hpp"
 
-namespace gui
-{
-  class Button;
-  class TextView;
-}
-
 class Framework;
 
 namespace storage { struct TIndex; }
 
 /// This class is a composite GUI element to display
 /// an on-screen GUI for the country, which is not downloaded yet.
-class CountryStatusDisplay : public gui::Element,
-                             public storage::ActiveMapsLayout::ActiveMapsListener
+class CountryStatusDisplay : public storage::ActiveMapsLayout::ActiveMapsListener
 {
-  typedef gui::Element TBase;
 public:
-  struct Params : public gui::Element::Params
+  struct Params
   {
     Params(storage::ActiveMapsLayout & activeMaps) : m_activeMaps(activeMaps) {}
 
@@ -48,20 +35,10 @@ public:
   //@{
   virtual void setIsVisible(bool isVisible) const;
   virtual void setIsDirtyLayout(bool isDirty) const;
-  virtual m2::RectD GetBoundRect() const;
-
-  void draw(graphics::OverlayRenderer * r, math::Matrix<double, 3, 3> const & m) const;
 
   void cache();
   void purge();
   void layout();
-
-  void setController(gui::Controller * controller);
-
-  bool onTapStarted(m2::PointD const & pt);
-  bool onTapMoved(m2::PointD const & pt);
-  bool onTapEnded(m2::PointD const & pt);
-  bool onTapCancelled(m2::PointD const & pt);
   //@}
 
 private:
@@ -90,11 +67,10 @@ private:
 
   void ComposeElementsForState();
 
-  typedef function<bool (unique_ptr<gui::Button> const &, m2::PointD const &)> TTapActionFn;
-  bool OnTapAction(TTapActionFn const & action, m2::PointD const & pt);
-  void OnButtonClicked(Element const * button);
-
-  void Repaint() const;
+  ///@TODO UVR
+  //typedef function<bool (unique_ptr<gui::Button> const &, m2::PointD const &)> TTapActionFn;
+  //bool OnTapAction(TTapActionFn const & action, m2::PointD const & pt);
+  //void OnButtonClicked(Element const * button);
 
   bool IsStatusFailed() const;
 
@@ -102,20 +78,10 @@ private:
   storage::ActiveMapsLayout & m_activeMaps;
   int m_activeMapsSlotID = 0;
 
-  unique_ptr<gui::TextView> m_label;
-  unique_ptr<gui::Button> m_primaryButton;
-  unique_ptr<gui::Button> m_secondaryButton;
-
   string m_displayMapName;
   mutable storage::TStatus m_countryStatus = storage::TStatus::EUnknown;
   storage::TIndex m_countryIdx;
   storage::LocalAndRemoteSizeT m_progressSize;
 
   TDownloadCountryFn m_downloadCallback;
-
-  void Lock() const;
-  void Unlock() const;
-#ifdef OMIM_OS_ANDROID
-  mutable threads::Mutex m_mutex;
-#endif
 };
diff --git a/map/framework.cpp b/map/framework.cpp
index 9582660e09..f0a17707e9 100644
--- a/map/framework.cpp
+++ b/map/framework.cpp
@@ -1,20 +1,7 @@
-#include "framework.hpp"
-#include "benchmark_provider.hpp"
-#include "benchmark_engine.hpp"
-#include "geourl_process.hpp"
-#include "navigator_utils.hpp"
-#include "ge0_parser.hpp"
-
-#include "render/cpu_drawer.hpp"
-#include "render/gpu_drawer.hpp"
-
-#ifndef USE_DRAPE
-  #include "render/feature_processor.hpp"
-  #include "render/drawer.hpp"
-  #include "render/proto_to_styles.hpp"
-#else
-  #include "../drape_frontend/visual_params.hpp"
-#endif // USE_DRAPE
+#include "map/framework.hpp"
+
+#include "map/geourl_process.hpp"
+#include "map/ge0_parser.hpp"
 
 #include "defines.hpp"
 
@@ -29,6 +16,8 @@
 #include "search/search_engine.hpp"
 #include "search/search_query_factory.hpp"
 
+#include "drape_frontend/visual_params.hpp"
+
 #include "indexer/categories_holder.hpp"
 #include "indexer/classificator_loader.hpp"
 #include "indexer/feature.hpp"
@@ -45,8 +34,6 @@
 
 #include "anim/controller.hpp"
 
-#include "gui/controller.hpp"
-
 #include "platform/local_country_file_utils.hpp"
 #include "platform/measurement_utils.hpp"
 #include "platform/mwm_version.hpp"
@@ -63,8 +50,6 @@
 #include "geometry/angles.hpp"
 #include "geometry/distance_on_sphere.hpp"
 
-#include "graphics/depth_constants.hpp"
-
 #include "base/math.hpp"
 #include "base/timer.hpp"
 #include "base/scope_guard.hpp"
@@ -143,13 +128,12 @@ void Framework::OnLocationUpdate(GpsInfo const & info)
   double distanceFromBegin = 0.0;
   MatchLocationToRoute(rInfo, routeMatchingInfo, hasDistanceFromBegin, distanceFromBegin);
 
-  shared_ptr<State> const & state = GetLocationState();
-  state->OnLocationUpdate(rInfo, m_routingSession.IsNavigable(), routeMatchingInfo);
-
-  if (state->IsModeChangeViewport())
-    UpdateUserViewportChanged();
+  ///@TODO UVR
+  //shared_ptr<State> const & state = GetLocationState();
+  //state->OnLocationUpdate(rInfo, m_routingSession.IsNavigable());
 
-  m_bmManager.UpdateRouteDistanceFromBegin(hasDistanceFromBegin ? distanceFromBegin : 0.0);
+  //if (state->IsModeChangeViewport())
+  //  UpdateUserViewportChanged();
 }
 
 void Framework::OnCompassUpdate(CompassInfo const & info)
@@ -161,12 +145,14 @@ void Framework::OnCompassUpdate(CompassInfo const & info)
   CompassInfo const & rInfo = info;
 #endif
 
-  GetLocationState()->OnCompassUpdate(rInfo);
+  ///@TODO UVR
+  //GetLocationState()->OnCompassUpdate(rInfo);
 }
 
 void Framework::StopLocationFollow()
 {
-  GetLocationState()->StopLocationFollow();
+  ///@TODO UVR
+  //GetLocationState()->StopLocationFollow();
 }
 
 InformationDisplay & Framework::GetInformationDisplay()
@@ -190,16 +176,13 @@ m2::PointD Framework::GetWidgetSize(InformationDisplay::WidgetType widget) const
 }
 
 Framework::Framework()
-  : m_navigator(m_scales),
-    m_animator(this),
+  : m_animator(this),
     m_queryMaxScaleMode(false),
     m_width(0),
     m_height(0),
     m_countryTree(*this),
-    m_guiController(new gui::Controller),
     m_animController(new anim::Controller),
     m_informationDisplay(this),
-    m_benchmarkEngine(0),
     m_bmManager(*this),
     m_balloonManager(*this),
     m_fixedSearchResults(0),
@@ -243,10 +226,9 @@ Framework::Framework()
   m_stringsBundle.SetDefaultString("routing_failed_route_not_found", "There is no route found between the selected origin and destination.Please select a different start or end point.");
   m_stringsBundle.SetDefaultString("routing_failed_internal_error", "Internal error occurred. Please try to delete and download the map again. If problem persist please contact us at support@maps.me.");
 
-  m_guiController->SetStringsBundle(&m_stringsBundle);
-
   // Init information display.
-  m_informationDisplay.setController(m_guiController.get());
+  ///@TODO UVR
+  //m_informationDisplay.setController(m_guiController.get());
 
 #ifdef DRAW_TOUCH_POINTS
   m_informationDisplay.enableDebugPoints(true);
@@ -299,7 +281,6 @@ Framework::Framework()
 
 Framework::~Framework()
 {
-  delete m_benchmarkEngine;
   m_model.SetOnMapDeregisteredCallback(nullptr);
 }
 
@@ -382,11 +363,6 @@ bool Framework::IsSingleFrameRendererInited() const
   return m_cpuDrawer != nullptr;
 }
 
-double Framework::GetVisualScale() const
-{
-  return m_scales.GetVisualScale();
-}
-
 void Framework::DeleteCountry(storage::TIndex const & index, MapOptions opt)
 {
   switch (opt)
@@ -401,7 +377,8 @@ void Framework::DeleteCountry(storage::TIndex const & index, MapOptions opt)
       // OnMapDeregistered call.
       if (m_model.DeregisterMap(countryFile))
       {
-        InvalidateRect(GetCountryBounds(countryFile.GetNameWithoutExt()), true /* doForceUpdate */);
+        ///@TODO UVR
+        //InvalidateRect(GetCountryBounds(countryFile.GetNameWithoutExt()), true /* doForceUpdate */);
       }
       return;
     }
@@ -461,7 +438,7 @@ void Framework::UpdateLatestCountryFile(LocalCountryFile const & localFile)
   auto p = m_model.RegisterMap(localFile);
   MwmSet::MwmId const & id = p.first;
   if (id.IsAlive())
-    InvalidateRect(id.GetInfo()->m_limitRect, true /* doForceUpdate */);
+    //InvalidateRect(handle.GetInfo()->m_limitRect, true /* doForceUpdate */);
 
   m_searchEngine->ClearViewportsCache();
 }
@@ -566,7 +543,7 @@ void Framework::ShowBookmark(BookmarkAndCategory const & bnc)
   if (scale == -1.0)
     scale = scales::GetUpperComfortScale();
 
-  ShowRectExVisibleScale(m_scales.GetRectForDrawScale(scale, bmk->GetOrg()));
+  ShowRectExVisibleScale(df::GetRectForDrawScale(scale, bmk->GetOrg()));
   Bookmark * mark = GetBmCategory(bnc.first)->GetBookmark(bnc.second);
   ActivateUserMark(mark);
   m_balloonManager.OnShowMark(mark);
@@ -656,11 +633,7 @@ bool Framework::AddBookmarksFile(string const & filePath)
 
 void Framework::PrepareToShutdown()
 {
-#ifndef USE_DRAPE
-  SetRenderPolicy(0);
-#else
-  m_drapeEngine.Destroy();
-#endif // USE_DRAPE
+  DestroyDrapeEngine();
 }
 
 void Framework::SetMaxWorldRect()
@@ -668,46 +641,6 @@ void Framework::SetMaxWorldRect()
   m_navigator.SetFromRect(m2::AnyRectD(m_model.GetWorldRect()));
 }
 
-bool Framework::NeedRedraw() const
-{
-  // Checking this here allows to avoid many dummy "IsInitialized" flags in client code.
-#ifndef USE_DRAPE
-  return (m_renderPolicy && m_renderPolicy->NeedRedraw());
-#else
-  return false;
-#endif // USE_DRAPE
-}
-
-void Framework::SetNeedRedraw(bool flag)
-{
-#ifndef USE_DRAPE
-  m_renderPolicy->GetWindowHandle()->setNeedRedraw(flag);
-  //if (!flag)
-  //  m_doForceUpdate = false;
-#endif // USE_DRAPE
-}
-
-void Framework::Invalidate(bool doForceUpdate)
-{
-  InvalidateRect(MercatorBounds::FullRect(), doForceUpdate);
-}
-
-void Framework::InvalidateRect(m2::RectD const & rect, bool doForceUpdate)
-{
-#ifndef USE_DRAPE
-  if (m_renderPolicy)
-  {
-    ASSERT ( rect.IsValid(), () );
-    m_renderPolicy->SetForceUpdate(doForceUpdate);
-    m_renderPolicy->SetInvalidRect(m2::AnyRectD(rect));
-    m_renderPolicy->GetWindowHandle()->invalidate();
-  }
-#else
-  if (!m_drapeEngine.IsNull())
-    m_drapeEngine->UpdateCoverage(m_navigator.Screen());
-#endif // USE_DRAPE
-}
-
 void Framework::SaveState()
 {
   Settings::Set("ScreenClipRect", m_navigator.Screen().GlobalRect());
@@ -715,28 +648,11 @@ void Framework::SaveState()
 
 bool Framework::LoadState()
 {
-  m2::AnyRectD rect;
-  if (!Settings::Get("ScreenClipRect", rect))
-    return false;
-
-  // additional check for valid rect
-  m2::RectD r = rect.GetGlobalRect();
-  if (!m_scales.GetWorldRect().IsRectInside(r))
-    return false;
-
-  CheckMinMaxVisibleScale(r);
-
-  double const dx = r.SizeX();
-  double const dy = r.SizeY();
-
-  m2::AnyRectD safeRect(r.Center(), rect.Angle(), m2::RectD(-dx/2, -dy/2, dx/2, dy/2));
-  m_navigator.SetFromRect(safeRect);
-
-#ifdef USE_DRAPE
+  bool r = m_navigator.LoadState();
+  LOG(LINFO, ("Navigator state loaded = ", r, " Rect = ", m_navigator.Screen().ClipRect()));
   if (!m_drapeEngine.IsNull())
     m_drapeEngine->UpdateCoverage(m_navigator.Screen());
-#endif
-  return true;
+  return r;
 }
 //@}
 
@@ -746,41 +662,22 @@ void Framework::OnSize(int w, int h)
   if (w < 2) w = 2;
   if (h < 2) h = 2;
 
-  m2::RectD oldPixelRect = m_navigator.Screen().PixelRect();
-
-#ifndef USE_DRAPE
-  m_navigator.OnSize(0, 0, w, h);
-  if (m_renderPolicy)
-  {
-    // if gui controller not initialized, than we work in mode "Without gui"
-    // and no need to set gui layout. We will not render it.
-    if (m_guiController->GetCacheScreen())
-      m_informationDisplay.SetWidgetPivotsByDefault(w, h);
-    m_renderPolicy->OnSize(w, h);
-  }
-#else
   if (!m_drapeEngine.IsNull())
   {
     double vs = df::VisualParams::Instance().GetVisualScale();
     m_navigator.OnSize(0, 0, vs * w, vs * h);
-    //m_navigator.OnSize(0, 0, w, h);
     m_drapeEngine->Resize(w, h);
     m_drapeEngine->UpdateCoverage(m_navigator.Screen());
   }
-#endif // USE_DRAPE
 
   m_width = w;
   m_height = h;
-  GetLocationState()->OnSize(oldPixelRect);
+  ///@TODO UVR
+  //GetLocationState()->OnSize();
 }
 
 bool Framework::SetUpdatesEnabled(bool doEnable)
 {
-#ifndef USE_DRAPE
-  if (m_renderPolicy)
-    return m_renderPolicy->GetWindowHandle()->setUpdatesEnabled(doEnable);
-  else
-#endif // USE_DRAPE
     return false;
 }
 
@@ -789,48 +686,6 @@ int Framework::GetDrawScale() const
   return m_navigator.GetDrawScale();
 }
 
-#ifndef USE_DRAPE
-RenderPolicy::TRenderFn Framework::DrawModelFn()
-{
-  bool const isTiling = m_renderPolicy->IsTiling();
-  return bind(&Framework::DrawModel, this, _1, _2, _3, _4, isTiling);
-}
-
-void Framework::DrawModel(shared_ptr<PaintEvent> const & e,
-                          ScreenBase const & screen,
-                          m2::RectD const & renderRect,
-                          int baseScale, bool isTilingQuery)
-{
-  m2::RectD selectRect;
-  m2::RectD clipRect;
-
-  double const inflationSize = m_scales.GetClipRectInflation();
-  screen.PtoG(m2::Inflate(m2::RectD(renderRect), inflationSize, inflationSize), clipRect);
-  screen.PtoG(m2::RectD(renderRect), selectRect);
-
-  int drawScale = m_scales.GetDrawTileScale(baseScale);
-  fwork::FeatureProcessor doDraw(clipRect, screen, e, drawScale);
-  if (m_queryMaxScaleMode)
-    drawScale = scales::GetUpperScale();
-
-  try
-  {
-    int const upperScale = scales::GetUpperScale();
-    if (isTilingQuery && drawScale <= upperScale)
-      m_model.ForEachFeature_TileDrawing(selectRect, doDraw, drawScale);
-    else
-      m_model.ForEachFeature(selectRect, doDraw, min(upperScale, drawScale));
-  }
-  catch (redraw_operation_cancelled const &)
-  {}
-
-  e->setIsEmptyDrawing(doDraw.IsEmptyDrawing());
-
-  if (m_navigator.Update(ElapsedSeconds()))
-    Invalidate();
-}
-#endif // USE_DRAPE
-
 bool Framework::IsCountryLoaded(m2::PointD const & pt) const
 {
   // TODO (@gorshenin, @govako): the method's name is quite
@@ -844,64 +699,41 @@ bool Framework::IsCountryLoaded(m2::PointD const & pt) const
   return m_model.IsLoaded(fName);
 }
 
-#ifndef USE_DRAPE
-void Framework::BeginPaint(shared_ptr<PaintEvent> const & e)
-{
-  if (m_renderPolicy)
-    m_renderPolicy->BeginFrame(e, m_navigator.Screen());
-}
+///@TODO UVR
+//void Framework::DrawAdditionalInfo(shared_ptr<PaintEvent> const & e)
+//{
+//  // m_informationDisplay is set and drawn after the m_renderPolicy
+//  ASSERT ( m_renderPolicy, () );
 
-void Framework::EndPaint(shared_ptr<PaintEvent> const & e)
-{
-  if (m_renderPolicy)
-    m_renderPolicy->EndFrame(e, m_navigator.Screen());
-}
+//  Drawer * pDrawer = e->drawer();
+//  graphics::Screen * pScreen = pDrawer->screen();
 
-void Framework::DrawAdditionalInfo(shared_ptr<PaintEvent> const & e)
-{
-  // m_informationDisplay is set and drawn after the m_renderPolicy
-  ASSERT ( m_renderPolicy, () );
+//  pScreen->beginFrame();
 
-  graphics::Screen * pScreen = GPUDrawer::GetScreen(e->drawer());
+//  bool const isEmptyModel = m_renderPolicy->IsEmptyModel();
 
-  pScreen->beginFrame();
+//  if (isEmptyModel)
+//    m_informationDisplay.setEmptyCountryIndex(GetCountryIndex(GetViewportCenter()));
+//  else
+//    m_informationDisplay.setEmptyCountryIndex(storage::TIndex());
 
-  int const drawScale = GetDrawScale();
-  bool const isEmptyModel = m_renderPolicy->IsEmptyModel();
+//  bool const isCompassEnabled = my::Abs(ang::GetShortestDistance(m_navigator.Screen().GetAngle(), 0.0)) > my::DegToRad(3.0);
+//  bool const isCompasActionEnabled = m_informationDisplay.isCompassArrowEnabled() && m_navigator.InAction();
 
-  if (isEmptyModel)
-    m_informationDisplay.setEmptyCountryIndex(GetCountryIndex(GetViewportCenter()));
-  else
-    m_informationDisplay.setEmptyCountryIndex(storage::TIndex());
-
-  bool const isCompassEnabled = my::Abs(ang::GetShortestDistance(m_navigator.Screen().GetAngle(), 0.0)) > my::DegToRad(3.0);
-  bool const isCompasActionEnabled = m_informationDisplay.isCompassArrowEnabled() && m_navigator.InAction();
+//  m_informationDisplay.enableCompassArrow(isCompassEnabled || isCompasActionEnabled);
+//  m_informationDisplay.setCompassArrowAngle(m_navigator.Screen().GetAngle());
 
-  m_informationDisplay.enableCompassArrow(isCompassEnabled || isCompasActionEnabled);
-  m_informationDisplay.setCompassArrowAngle(m_navigator.Screen().GetAngle());
+//  int const drawScale = GetDrawScale();
+//  m_informationDisplay.setDebugInfo(0, drawScale);
 
-  m_informationDisplay.enableRuler(!m_isFullScreenMode && (drawScale > 4 && !m_informationDisplay.isCopyrightActive()));
+//  m_informationDisplay.enableRuler(drawScale > 4 && !m_informationDisplay.isCopyrightActive());
 
-  m_informationDisplay.setDebugInfo(0, drawScale);
-  pScreen->endFrame();
+//  pScreen->endFrame();
 
-  m_bmManager.DrawItems(e->drawer());
-  m_guiController->UpdateElements();
-  m_guiController->DrawFrame(pScreen);
-}
-
-void Framework::DoPaint(shared_ptr<PaintEvent> const & e)
-{
-  if (m_renderPolicy)
-  {
-    m_renderPolicy->DrawFrame(e, m_navigator.Screen());
-
-    // Don't render additional elements if guiController wasn't initialized.
-    if (m_guiController->GetCacheScreen() != NULL)
-      DrawAdditionalInfo(e);
-  }
-}
-#endif // USE_DRAPE
+//  m_bmManager.DrawItems(e);
+//  m_guiController->UpdateElements();
+//  m_guiController->DrawFrame(pScreen);
+//}
 
 m2::PointD const & Framework::GetViewportCenter() const
 {
@@ -911,7 +743,8 @@ m2::PointD const & Framework::GetViewportCenter() const
 void Framework::SetViewportCenter(m2::PointD const & pt)
 {
   m_navigator.CenterViewport(pt);
-  Invalidate();
+  if (!m_drapeEngine.IsNull())
+    m_drapeEngine->UpdateCoverage(m_navigator.Screen());
 }
 
 shared_ptr<MoveScreenTask> Framework::SetViewportCenterAnimated(m2::PointD const & endPt)
@@ -923,7 +756,7 @@ shared_ptr<MoveScreenTask> Framework::SetViewportCenterAnimated(m2::PointD const
 
 void Framework::CheckMinGlobalRect(m2::RectD & rect) const
 {
-  m2::RectD const minRect = m_scales.GetRectForDrawScale(scales::GetUpperStyleScale(), rect.Center());
+  m2::RectD const minRect = df::GetRectForDrawScale(scales::GetUpperStyleScale(), rect.Center());
   if (minRect.IsRectInside(rect))
     rect = minRect;
 }
@@ -935,30 +768,25 @@ void Framework::CheckMinMaxVisibleScale(m2::RectD & rect, int maxScale/* = -1*/)
   m2::PointD const c = rect.Center();
   int const worldS = scales::GetUpperWorldScale();
 
-  int scale = m_scales.GetDrawTileScale(rect);
+  int scale = df::GetDrawTileScale(rect);
   if (scale > worldS && !IsCountryLoaded(c))
   {
     // country is not loaded - limit on world scale
-    rect = m_scales.GetRectForDrawScale(worldS, c);
+    rect = df::GetRectForDrawScale(worldS, c);
     scale = worldS;
   }
 
   if (maxScale != -1 && scale > maxScale)
   {
     // limit on passed maximal scale
-    rect = m_scales.GetRectForDrawScale(maxScale, c);
+    rect = df::GetRectForDrawScale(maxScale, c);
   }
 }
 
 void Framework::ShowRect(double lat, double lon, double zoom)
 {
   m2::PointD center(MercatorBounds::FromLatLon(lat, lon));
-  ShowRect(center, zoom);
-}
-
-void Framework::ShowRect(m2::PointD const & pt, double zoom)
-{
-  ShowRectEx(m_scales.GetRectForDrawScale(zoom, pt));
+  ShowRectEx(df::GetRectForDrawScale(zoom, center));
 }
 
 void Framework::ShowRect(m2::RectD rect)
@@ -966,7 +794,8 @@ void Framework::ShowRect(m2::RectD rect)
   CheckMinGlobalRect(rect);
 
   m_navigator.SetFromRect(m2::AnyRectD(rect));
-  Invalidate();
+  ///@TODO UVR
+  //Invalidate();
 }
 
 void Framework::ShowRectEx(m2::RectD rect)
@@ -990,8 +819,16 @@ void Framework::ShowRectFixed(m2::RectD const & rect)
 
 void Framework::ShowRectFixedAR(m2::AnyRectD const & rect)
 {
-  navi::SetRectFixedAR(rect, m_scales, m_navigator);
-  Invalidate();
+  double const halfSize = df::VisualParams::Instance().GetTileSize() / 2.0;
+  m2::RectD etalonRect(-halfSize, -halfSize, halfSize, halfSize);
+
+  m2::PointD const pxCenter = m_navigator.Screen().PixelRect().Center();
+  etalonRect.Offset(pxCenter);
+
+  m_navigator.SetFromRects(rect, etalonRect);
+
+  ///@TODO UVR
+  //Invalidate();
 }
 
 void Framework::StartInteractiveSearch(search::SearchParams const & params)
@@ -1027,6 +864,17 @@ void Framework::UpdateSearchResults(search::Results const & results)
   Invalidate();
 }
 
+void Framework::OnSearchResultsCallbackUI(search::Results const & results)
+{
+  if (IsISActive())
+  {
+    FillSearchResultsMarks(results);
+
+    ///@TODO UVR
+    //Invalidate();
+  }
+}
+
 void Framework::ClearAllCaches()
 {
   m_model.ClearCaches();
@@ -1063,7 +911,8 @@ void Framework::EnterForeground()
 void Framework::ShowAll()
 {
   SetMaxWorldRect();
-  Invalidate();
+  ///@TODO UVR
+  //Invalidate();
 }
 
 /// @name Drag implementation.
@@ -1076,90 +925,65 @@ m2::PointD Framework::GetPixelCenter() const
 void Framework::StartDrag(DragEvent const & e)
 {
   m_navigator.StartDrag(m_navigator.ShiftPoint(e.Pos()), ElapsedSeconds());
-  m_informationDisplay.locationState()->DragStarted();
+  ///@TODO UVR
+  //m_informationDisplay.locationState()->DragStarted();
 
-#ifndef USE_DRAPE
-  if (m_renderPolicy)
-    m_renderPolicy->StartDrag();
-#else
   if (!m_drapeEngine.IsNull())
     m_drapeEngine->UpdateCoverage(m_navigator.Screen());
-#endif // USE_DRAPE
 }
 
 void Framework::DoDrag(DragEvent const & e)
 {
   m_navigator.DoDrag(m_navigator.ShiftPoint(e.Pos()), ElapsedSeconds());
 
-#ifndef USE_DRAPE
-  if (m_renderPolicy)
-    m_renderPolicy->DoDrag();
-#else
   if (!m_drapeEngine.IsNull())
     m_drapeEngine->UpdateCoverage(m_navigator.Screen());
-#endif // USE_DRAPE
 }
 
 void Framework::StopDrag(DragEvent const & e)
 {
   m_navigator.StopDrag(m_navigator.ShiftPoint(e.Pos()), ElapsedSeconds(), true);
-  m_informationDisplay.locationState()->DragEnded();
+  ///@TODO UVR
+  //m_informationDisplay.locationState()->DragEnded();
 
-#ifndef USE_DRAPE
-  if (m_renderPolicy)
-  {
-    m_renderPolicy->StopDrag();
-    UpdateUserViewportChanged();
-  }
-#else
   if (!m_drapeEngine.IsNull())
     m_drapeEngine->UpdateCoverage(m_navigator.Screen());
-#endif // USE_DRAPE
 }
 
 void Framework::StartRotate(RotateEvent const & e)
 {
   m_navigator.StartRotate(e.Angle(), ElapsedSeconds());
-#ifndef USE_DRAPE
-  m_renderPolicy->StartRotate(e.Angle(), ElapsedSeconds());
-#else
   if (!m_drapeEngine.IsNull())
     m_drapeEngine->UpdateCoverage(m_navigator.Screen());
-#endif // USE_DRAPE
-  GetLocationState()->ScaleStarted();
+
+  ///@TODO UVR
+  //GetLocationState()->ScaleStarted();
 }
 
 void Framework::DoRotate(RotateEvent const & e)
 {
   m_navigator.DoRotate(e.Angle(), ElapsedSeconds());
-#ifndef USE_DRAPE
-  m_renderPolicy->DoRotate(e.Angle(), ElapsedSeconds());
-#else
   if (!m_drapeEngine.IsNull())
     m_drapeEngine->UpdateCoverage(m_navigator.Screen());
-#endif
 }
 
 void Framework::StopRotate(RotateEvent const & e)
 {
   m_navigator.StopRotate(e.Angle(), ElapsedSeconds());
-  shared_ptr<State> const & state = GetLocationState();
-  state->Rotated();
-  state->ScaleEnded();
-#ifndef USE_DRAPE
-  m_renderPolicy->StopRotate(e.Angle(), ElapsedSeconds());
-#else
+  ///@TODO UVR
+  //GetLocationState()->Rotated();
+  //GetLocationState()->ScaleEnded();
   if (!m_drapeEngine.IsNull())
     m_drapeEngine->UpdateCoverage(m_navigator.Screen());
-#endif
+
   UpdateUserViewportChanged();
 }
 
 void Framework::Move(double azDir, double factor)
 {
   m_navigator.Move(azDir, factor);
-
-  Invalidate();
+  if (!m_drapeEngine.IsNull())
+    m_drapeEngine->UpdateCoverage(m_navigator.Screen());
 }
 //@}
 
@@ -1168,14 +992,17 @@ void Framework::Move(double azDir, double factor)
 void Framework::ScaleToPoint(ScaleToPointEvent const & e, bool anim)
 {
   m2::PointD pt = m_navigator.ShiftPoint(e.Pt());
-  GetLocationState()->CorrectScalePoint(pt);
+  ///@TODO UVR
+  //GetLocationState()->CorrectScalePoint(pt);
 
   if (anim)
     m_animController->AddTask(m_navigator.ScaleToPointAnim(pt, e.ScaleFactor(), 0.25));
   else
     m_navigator.ScaleToPoint(pt, e.ScaleFactor(), 0);
 
-  Invalidate();
+  if (!m_drapeEngine.IsNull())
+    m_drapeEngine->UpdateCoverage(m_navigator.Screen());
+
   UpdateUserViewportChanged();
 }
 
@@ -1187,10 +1014,13 @@ void Framework::ScaleDefault(bool enlarge)
 void Framework::Scale(double scale)
 {
   m2::PointD center = GetPixelCenter();
-  GetLocationState()->CorrectScalePoint(center);
+  ///@TODO UVR
+  //GetLocationState()->CorrectScalePoint(center);
   m_animController->AddTask(m_navigator.ScaleToPointAnim(center, scale, 0.25));
 
-  Invalidate();
+  if (!m_drapeEngine.IsNull())
+    m_drapeEngine->UpdateCoverage(m_navigator.Screen());
+
   UpdateUserViewportChanged();
 }
 
@@ -1199,23 +1029,21 @@ void Framework::CalcScalePoints(ScaleEvent const & e, m2::PointD & pt1, m2::Poin
   pt1 = m_navigator.ShiftPoint(e.Pt1());
   pt2 = m_navigator.ShiftPoint(e.Pt2());
 
-  m_informationDisplay.locationState()->CorrectScalePoint(pt1, pt2);
+  ///@TODO UVR
+  //m_informationDisplay.locationState()->CorrectScalePoint(pt1, pt2);
 }
-
 void Framework::StartScale(ScaleEvent const & e)
 {
   m2::PointD pt1, pt2;
   CalcScalePoints(e, pt1, pt2);
 
-  GetLocationState()->ScaleStarted();
+  ///@TODO UVR
+  //GetLocationState()->ScaleStarted();
   m_navigator.StartScale(pt1, pt2, ElapsedSeconds());
-#ifndef USE_DRAPE
-  if (m_renderPolicy)
-    m_renderPolicy->StartScale();
-#else
+
   if (!m_drapeEngine.IsNull())
     m_drapeEngine->UpdateCoverage(m_navigator.Screen());
-#endif // USE_DRAPE
+
 }
 
 void Framework::DoScale(ScaleEvent const & e)
@@ -1224,16 +1052,12 @@ void Framework::DoScale(ScaleEvent const & e)
   CalcScalePoints(e, pt1, pt2);
 
   m_navigator.DoScale(pt1, pt2, ElapsedSeconds());
-#ifndef USE_DRAPE
-  if (m_renderPolicy)
-    m_renderPolicy->DoScale();
-#else
   if (!m_drapeEngine.IsNull())
     m_drapeEngine->UpdateCoverage(m_navigator.Screen());
-#endif // USE_DRAPE
 
-  if (m_navigator.IsRotatingDuringScale())
-    GetLocationState()->Rotated();
+  ///@TODO UVR
+//  if (m_navigator.IsRotatingDuringScale())
+//    GetLocationState()->Rotated();
 }
 
 void Framework::StopScale(ScaleEvent const & e)
@@ -1243,18 +1067,14 @@ void Framework::StopScale(ScaleEvent const & e)
 
   m_navigator.StopScale(pt1, pt2, ElapsedSeconds());
 
-#ifndef USE_DRAPE
-  if (m_renderPolicy)
+  if (!m_drapeEngine.IsNull())
   {
-    m_renderPolicy->StopScale();
+    m_drapeEngine->UpdateCoverage(m_navigator.Screen());
     UpdateUserViewportChanged();
   }
-#else
-  if (!m_drapeEngine.IsNull())
-    m_drapeEngine->UpdateCoverage(m_navigator.Screen());
-#endif // USE_DRAPE
 
-  GetLocationState()->ScaleEnded();
+  ///@TODO UVR
+  //GetLocationState()->ScaleEnded();
 }
 //@}
 
@@ -1333,16 +1153,17 @@ bool Framework::Search(search::SearchParams const & params)
 
 bool Framework::GetCurrentPosition(double & lat, double & lon) const
 {
-  shared_ptr<State> const & locationState = m_informationDisplay.locationState();
-
-  if (locationState->IsModeHasPosition())
-  {
-    m2::PointD const pos = locationState->Position();
-    lat = MercatorBounds::YToLat(pos.y);
-    lon = MercatorBounds::XToLon(pos.x);
-    return true;
-  }
-  else
+  ///@TODO UVR
+  //shared_ptr<State> const & locationState = m_informationDisplay.locationState();
+
+//  if (locationState->IsModeHasPosition())
+//  {
+//    m2::PointD const pos = locationState->Position();
+//    lat = MercatorBounds::YToLat(pos.y);
+//    lon = MercatorBounds::XToLon(pos.x);
+//    return true;
+//  }
+//  else
     return false;
 }
 
@@ -1406,7 +1227,7 @@ void Framework::ShowSearchResult(search::Result const & res)
   }
 
   StopLocationFollow();
-  ShowRectExVisibleScale(m_scales.GetRectForDrawScale(scale, center));
+  ShowRectExVisibleScale(df::GetRectForDrawScale(scale, center));
 
   search::AddressInfo info;
   info.MakeFrom(res);
@@ -1441,8 +1262,9 @@ size_t Framework::ShowAllSearchResults(search::Results const & results)
   FillSearchResultsMarks(results);
   m_fixedSearchResults = count;
 
-  shared_ptr<State> state = GetLocationState();
-  state->SetFixedZoom();
+  ///@TODO UVR
+  //shared_ptr<State> state = GetLocationState();
+  //state->SetFixedZoom();
   // Setup viewport according to results.
   m2::AnyRectD viewport = m_navigator.Screen().GlobalRect();
   m2::PointD const center = viewport.Center();
@@ -1477,8 +1299,9 @@ size_t Framework::ShowAllSearchResults(search::Results const & results)
       minInd = -1;
   }
 
-  if (minInd == -1)
-    Invalidate();
+  if (minInd == -1);
+    ///@TODO UVR
+    //Invalidate();
 
   return count;
 }
@@ -1515,7 +1338,8 @@ void Framework::CancelInteractiveSearch()
 
   m_fixedSearchResults = 0;
 
-  Invalidate();
+  ///@TODO UVR
+  //Invalidate();
 }
 
 bool Framework::GetDistanceAndAzimut(m2::PointD const & point,
@@ -1553,71 +1377,6 @@ bool Framework::GetDistanceAndAzimut(m2::PointD const & point,
   return (d < 25000.0);
 }
 
-#ifndef USE_DRAPE
-void Framework::SetRenderPolicy(RenderPolicy * renderPolicy)
-{
-  if (renderPolicy == nullptr)
-    m_bmManager.PrepareToShutdown();
-
-  m_bmManager.ResetScreen();
-  m_guiController->ResetRenderParams();
-  m_renderPolicy.reset();
-  m_renderPolicy.reset(renderPolicy);
-
-  if (m_renderPolicy)
-  {
-    m_renderPolicy->SetAnimController(m_animController.get());
-
-    m_renderPolicy->SetRenderFn(DrawModelFn());
-
-    m_scales.SetParams(m_renderPolicy->VisualScale(), m_renderPolicy->TileSize());
-
-    if (m_benchmarkEngine)
-      m_benchmarkEngine->Start();
-  }
-}
-
-void Framework::InitGuiSubsystem()
-{
-  if (m_renderPolicy)
-  {
-    gui::Controller::RenderParams rp(m_renderPolicy->Density(),
-                                     m_renderPolicy->DensityExactDPI(),
-                                     bind(&WindowHandle::invalidate,
-                                          m_renderPolicy->GetWindowHandle().get()),
-                                     m_renderPolicy->GetGlyphCache(),
-                                     m_renderPolicy->GetCacheScreen().get());
-
-    m_guiController->SetRenderParams(rp);
-    m_informationDisplay.setVisualScale(m_renderPolicy->VisualScale());
-    m_balloonManager.RenderPolicyCreated(m_renderPolicy->Density());
-
-    if (m_width != 0 && m_height != 0)
-      OnSize(m_width, m_height);
-
-    // init Bookmark manager
-    //@{
-    graphics::Screen::Params pr;
-    pr.m_resourceManager = m_renderPolicy->GetResourceManager();
-    pr.m_threadSlot = m_renderPolicy->GetResourceManager()->guiThreadSlot();
-    pr.m_renderContext = m_renderPolicy->GetRenderContext();
-
-    pr.m_storageType = graphics::EMediumStorage;
-    pr.m_textureType = graphics::ESmallTexture;
-
-    m_bmManager.SetScreen(m_renderPolicy->GetCacheScreen().get());
-    //@}
-
-    // Do full invalidate instead of any "pending" stuff.
-    Invalidate();
-  }
-}
-
-RenderPolicy * Framework::GetRenderPolicy() const
-{
-  return m_renderPolicy.get();
-}
-#else
 void Framework::CreateDrapeEngine(dp::RefPointer<dp::OGLContextFactory> contextFactory, float vs, int w, int h)
 {
   typedef df::MapDataProvider::TReadIDsFn TReadIDsFn;
@@ -1638,7 +1397,11 @@ void Framework::CreateDrapeEngine(dp::RefPointer<dp::OGLContextFactory> contextF
   m_drapeEngine.Reset(new df::DrapeEngine(contextFactory, df::Viewport(vs, 0, 0, w, h), df::MapDataProvider(idReadFn, featureReadFn)));
   OnSize(w, h);
 }
-#endif // USE_DRAPE
+
+void Framework::DestroyDrapeEngine()
+{
+  m_drapeEngine.Destroy();
+}
 
 void Framework::SetMapStyle(MapStyle mapStyle)
 {
@@ -1664,7 +1427,8 @@ void Framework::SetupMeasurementSystem()
 
   m_routingSession.SetTurnNotificationsUnits(units);
   m_informationDisplay.measurementSystemChanged();
-  Invalidate();
+  ///@TODO UVR
+  //Invalidate();
 }
 
 string Framework::GetCountryCode(m2::PointD const & pt) const
@@ -1674,11 +1438,6 @@ string Framework::GetCountryCode(m2::PointD const & pt) const
   return info.m_flag;
 }
 
-gui::Controller * Framework::GetGuiController() const
-{
-  return m_guiController.get();
-}
-
 anim::Controller * Framework::GetAnimController() const
 {
   return m_animController.get();
@@ -1709,7 +1468,7 @@ bool Framework::ShowMapForURL(string const & url)
     if (parser.Parse(url, pt, zoom))
     {
       point = MercatorBounds::FromLatLon(pt.m_lat, pt.m_lon);
-      rect = m_scales.GetRectForDrawScale(zoom, point);
+      rect = df::GetRectForDrawScale(zoom, point);
       name = pt.m_name;
       result = NEED_CLICK;
     }
@@ -1720,8 +1479,8 @@ bool Framework::ShowMapForURL(string const & url)
 
     if (m_ParsedMapApi.SetUriAndParse(url))
     {
-      if (!m_ParsedMapApi.GetViewportRect(m_scales, rect))
-        rect = ScalesProcessor::GetWorldRect();
+      if (!m_ParsedMapApi.GetViewportRect(rect))
+        rect = df::GetWorldRect();
 
       if ((apiMark = m_ParsedMapApi.GetSinglePoint()))
         result = NEED_CLICK;
@@ -1736,7 +1495,7 @@ bool Framework::ShowMapForURL(string const & url)
     if (info.IsValid())
     {
       point = MercatorBounds::FromLatLon(info.m_lat, info.m_lon);
-      rect = m_scales.GetRectForDrawScale(info.m_zoom, point);
+      rect = df::GetRectForDrawScale(info.m_zoom, point);
       result = NEED_CLICK;
     }
   }
@@ -1792,7 +1551,8 @@ void Framework::DisconnectMyPositionUpdate()
 {
   if (m_locationChangedSlotID != -1)
   {
-    GetLocationState()->RemovePositionChangedListener(m_locationChangedSlotID);
+    ///@TODO UVR
+    //GetLocationState()->RemovePositionChangedListener(m_locationChangedSlotID);
     m_locationChangedSlotID = -1;
   }
 }
@@ -1802,90 +1562,80 @@ m2::RectD Framework::GetCurrentViewport() const
   return m_navigator.Screen().ClipRect();
 }
 
-bool Framework::IsBenchmarking() const
-{
-  return m_benchmarkEngine != 0;
-}
-
-#ifndef USE_DRAPE
 namespace
 {
 
-typedef shared_ptr<graphics::OverlayElement> OEPointerT;
-
-OEPointerT GetClosestToPivot(list<OEPointerT> const & l, m2::PointD const & pxPoint)
-{
-  double dist = numeric_limits<double>::max();
-  OEPointerT res;
+///@TODO UVR
+//OEPointerT GetClosestToPivot(list<OEPointerT> const & l, m2::PointD const & pxPoint)
+//{
+//  double dist = numeric_limits<double>::max();
+//  OEPointerT res;
 
-  for (list<OEPointerT>::const_iterator it = l.begin(); it != l.end(); ++it)
-  {
-    double const curDist = pxPoint.SquareLength((*it)->pivot());
-    if (curDist < dist)
-    {
-      dist = curDist;
-      res = *it;
-    }
-  }
+//  for (list<OEPointerT>::const_iterator it = l.begin(); it != l.end(); ++it)
+//  {
+//    double const curDist = pxPoint.SquareLength((*it)->pivot());
+//    if (curDist < dist)
+//    {
+//      dist = curDist;
+//      res = *it;
+//    }
+//  }
 
-  return res;
-}
+//  return res;
+//}
 
 }
-#endif // USE_DRAPE
 
 bool Framework::GetVisiblePOI(m2::PointD const & pxPoint, m2::PointD & pxPivot,
                               search::AddressInfo & info, feature::Metadata & metadata) const
 {
-#ifndef USE_DRAPE
-  ASSERT(m_renderPolicy, ());
-  graphics::OverlayElement::UserInfo ui;
+///@TODO UVR
+//  graphics::OverlayElement::UserInfo ui;
 
-  {
-    // It seems like we don't need to lock frame here.
-    // Overlay locking and storing items as shared_ptr is enough here.
-    //m_renderPolicy->FrameLock();
+//  {
+//    // It seems like we don't need to lock frame here.
+//    // Overlay locking and storing items as shared_ptr is enough here.
+//    //m_renderPolicy->FrameLock();
 
-    m2::PointD const pt = m_navigator.ShiftPoint(pxPoint);
-    double const halfSize = TOUCH_PIXEL_RADIUS * GetVisualScale();
+//    m2::PointD const pt = m_navigator.ShiftPoint(pxPoint);
+//    double const halfSize = TOUCH_PIXEL_RADIUS * GetVisualScale();
 
-    list<OEPointerT> candidates;
-    m2::RectD const rect(pt.x - halfSize, pt.y - halfSize,
-                         pt.x + halfSize, pt.y + halfSize);
+//    list<OEPointerT> candidates;
+//    m2::RectD const rect(pt.x - halfSize, pt.y - halfSize,
+//                         pt.x + halfSize, pt.y + halfSize);
 
-    graphics::Overlay * frameOverlay = m_renderPolicy->FrameOverlay();
-    frameOverlay->lock();
-    frameOverlay->selectOverlayElements(rect, candidates);
-    frameOverlay->unlock();
+//    graphics::Overlay * frameOverlay = m_renderPolicy->FrameOverlay();
+//    frameOverlay->lock();
+//    frameOverlay->selectOverlayElements(rect, candidates);
+//    frameOverlay->unlock();
 
-    OEPointerT elem = GetClosestToPivot(candidates, pt);
+//    OEPointerT elem = GetClosestToPivot(candidates, pt);
 
-    if (elem)
-      ui = elem->userInfo();
+//    if (elem)
+//      ui = elem->userInfo();
 
-    //m_renderPolicy->FrameUnlock();
-  }
+//    //m_renderPolicy->FrameUnlock();
+//  }
 
-  if (ui.IsValid())
-  {
-    Index::FeaturesLoaderGuard guard(m_model.GetIndex(), ui.m_featureID.m_mwmId);
+  //if (ui.IsValid())
+  //{
+    //Index::FeaturesLoaderGuard guard(m_model.GetIndex(), ui.m_featureID.m_mwmId);
 
-    FeatureType ft;
-    guard.GetFeatureByIndex(ui.m_featureID.m_index, ft);
+    //FeatureType ft;
+    //guard.GetFeatureByIndex(ui.m_featureID.m_index, ft);
 
-    ft.ParseMetadata();
-    metadata = ft.GetMetadata();
+    //ft.ParseMetadata();
+    //metadata = ft.GetMetadata();
 
     // @TODO experiment with other pivots
-    ASSERT_NOT_EQUAL(ft.GetFeatureType(), feature::GEOM_LINE, ());
-    m2::PointD const center = feature::GetCenter(ft);
+    //ASSERT_NOT_EQUAL(ft.GetFeatureType(), feature::GEOM_LINE, ());
+    //m2::PointD const center = feature::GetCenter(ft);
 
-    GetAddressInfo(ft, center, info);
+//    GetAddressInfo(ft, center, info);
 
-    pxPivot = GtoP(center);
-    return true;
-  }
-#endif // USE_DRAPE
+//    pxPivot = GtoP(center);
+//    return true;
+//  }
 
   return false;
 }
@@ -1958,10 +1708,10 @@ Navigator & Framework::GetNavigator()
   return m_navigator;
 }
 
-shared_ptr<State> const & Framework::GetLocationState() const
-{
-  return m_informationDisplay.locationState();
-}
+//shared_ptr<State> const & Framework::GetLocationState() const
+//{
+//  return m_informationDisplay.locationState();
+//}
 
 void Framework::ActivateUserMark(UserMark const * mark, bool needAnim)
 {
@@ -1992,27 +1742,29 @@ UserMark const * Framework::GetUserMarkWithoutLogging(m2::PointD const & pxPoint
 {
   DisconnectMyPositionUpdate();
   m2::AnyRectD rect;
-  m_navigator.GetTouchRect(pxPoint, TOUCH_PIXEL_RADIUS * GetVisualScale(), rect);
-
-  shared_ptr<State> const & locationState = GetLocationState();
-  if (locationState->IsModeHasPosition())
-  {
-    m2::PointD const & glPivot = locationState->Position();
-    if (rect.IsPointInside(glPivot))
-    {
-      search::AddressInfo info;
-      info.m_name = m_stringsBundle.GetString("my_position");
-      MyPositionMarkPoint * myPostition = UserMarkContainer::UserMarkForMyPostion();
-      m_locationChangedSlotID = locationState->AddPositionChangedListener(bind(&Framework::UpdateSelectedMyPosition, this, _1));
-      myPostition->SetPtOrg(glPivot);
-      myPostition->SetInfo(info);
-      return myPostition;
-    }
-  }
+  double vs = df::VisualParams::Instance().GetVisualScale();
+  m_navigator.GetTouchRect(pxPoint, TOUCH_PIXEL_RADIUS * vs, rect);
+
+  ///@TODO UVR
+  //shared_ptr<State> const & locationState = GetLocationState();
+//  if (locationState->IsModeHasPosition())
+//  {
+//    m2::PointD const & glPivot = locationState->Position();
+//    if (rect.IsPointInside(glPivot))
+//    {
+//      search::AddressInfo info;
+//      info.m_name = m_stringsBundle.GetString("my_position");
+//      MyPositionMarkPoint * myPostition = UserMarkContainer::UserMarkForMyPostion();
+//      m_locationChangedSlotID = locationState->AddPositionChangedListener(bind(&Framework::UpdateSelectedMyPosition, this, _1));
+//      myPostition->SetPtOrg(glPivot);
+//      myPostition->SetInfo(info);
+//      return myPostition;
+//    }
+//  }
 
   m2::AnyRectD bmSearchRect;
-  double const pxWidth  =  TOUCH_PIXEL_RADIUS * GetVisualScale();
-  double const pxHeight = (TOUCH_PIXEL_RADIUS + BM_TOUCH_PIXEL_INCREASE) * GetVisualScale();
+  double const pxWidth  =  TOUCH_PIXEL_RADIUS * vs;
+  double const pxHeight = (TOUCH_PIXEL_RADIUS + BM_TOUCH_PIXEL_INCREASE) * vs;
   m_navigator.GetTouchRect(pxPoint + m2::PointD(0, BM_TOUCH_PIXEL_INCREASE), pxWidth, pxHeight, bmSearchRect);
 
   UserMark const * mark = m_bmManager.FindNearestUserMark(
@@ -2158,48 +1910,56 @@ void Framework::UpdateSavedDataVersion()
 
 void Framework::BuildRoute(m2::PointD const & start, m2::PointD const & finish, uint32_t timeoutSec)
 {
-  ASSERT_THREAD_CHECKER(m_threadChecker, ("BuildRoute"));
-
-  if (IsRoutingActive())
-    CloseRouting();
-
-  SetLastUsedRouter(m_currentRouterType);
-
-  auto readyCallback = [this](Route const & route, IRouter::ResultCode code)
-  {
-    ASSERT_THREAD_CHECKER(m_threadChecker, ("BuildRoute_ReadyCallback"));
-
-    vector<storage::TIndex> absentCountries;
-    vector<storage::TIndex> absentRoutingIndexes;
-    if (code == IRouter::NoError)
-    {
-      InsertRoute(route);
-      GetLocationState()->RouteBuilded();
-      ShowRectExVisibleScale(route.GetPoly().GetLimitRect());
-    }
-    else
-    {
-      for (string const & name : route.GetAbsentCountries())
-      {
-        storage::TIndex fileIndex = m_storage.FindIndexByFile(name);
-        if (m_storage.GetLatestLocalFile(fileIndex) && code != IRouter::FileTooOld)
-          absentRoutingIndexes.push_back(fileIndex);
-        else
-          absentCountries.push_back(fileIndex);
-      }
-
-      if (code != IRouter::NeedMoreMaps)
-        RemoveRoute();
-    }
-    CallRouteBuilded(code, absentCountries, absentRoutingIndexes);
-  };
-
-  m_routingSession.BuildRoute(start, finish,
-                              [readyCallback](Route const & route, IRouter::ResultCode code)
-                              {
-                                GetPlatform().RunOnGuiThread(bind(readyCallback, route, code));
-                              },
-                              m_progressCallback, timeoutSec);
+  //ASSERT_THREAD_CHECKER(m_threadChecker, ("BuildRoute"));
+
+  //shared_ptr<State> const & state = GetLocationState();
+  //if (!state->IsModeHasPosition())
+  //{
+  //  CallRouteBuilded(IRouter::NoCurrentPosition, vector<storage::TIndex>(),
+  //                   vector<storage::TIndex>());
+  //  return;
+  //}
+
+  //if (IsRoutingActive())
+  //  CloseRouting();
+
+  //SetLastUsedRouter(m_currentRouterType);
+
+  //auto readyCallback = [this](Route const & route, IRouter::ResultCode code)
+  //{
+  //  ASSERT_THREAD_CHECKER(m_threadChecker, ("BuildRoute_ReadyCallback"));
+
+  //  vector<storage::TIndex> absentCountries;
+  //  vector<storage::TIndex> absentRoutingIndexes;
+  //  if (code == IRouter::NoError)
+  //  {
+  //    InsertRoute(route);
+  //    GetLocationState()->RouteBuilded();
+  //    ShowRectExVisibleScale(route.GetPoly().GetLimitRect());
+  //  }
+  //  else
+  //  {
+  //    for (string const & name : route.GetAbsentCountries())
+  //    {
+  //      storage::TIndex fileIndex = m_storage.FindIndexByFile(name);
+  //      if (m_storage.GetLatestLocalFile(fileIndex) && code != IRouter::FileTooOld)
+  //        absentRoutingIndexes.push_back(fileIndex);
+  //      else
+  //        absentCountries.push_back(fileIndex);
+  //    }
+
+  //    if (code != IRouter::NeedMoreMaps)
+  //      RemoveRoute();
+  //  }
+  //  CallRouteBuilded(code, absentCountries, absentRoutingIndexes);
+  //};
+
+  //m_routingSession.BuildRoute(state->Position(), destination,
+  //                            [readyCallback](Route const & route, IRouter::ResultCode code)
+  //                            {
+  //                              GetPlatform().RunOnGuiThread(bind(readyCallback, route, code));
+  //                            },
+  //                            m_progressCallback, timeoutSec);
 }
 
 void Framework::SetRouter(RouterType type)
@@ -2277,10 +2037,12 @@ void Framework::CloseRouting()
 {
   ASSERT_THREAD_CHECKER(m_threadChecker, ("CloseRouting"));
 
-  GetLocationState()->StopRoutingMode();
+  ///@TODO UVR
+  //GetLocationState()->StopRoutingMode();
   m_routingSession.Reset();
   RemoveRoute();
-  Invalidate();
+  ///@TODO UVR
+  //Invalidate();
 }
 
 void Framework::InsertRoute(Route const & route)
@@ -2293,23 +2055,30 @@ void Framework::InsertRoute(Route const & route)
     return;
   }
 
-  vector<double> turnsDistances;
-  if (m_currentRouterType == RouterType::Vehicle)
-  {
-    route.GetTurnsDistances(turnsDistances);
-  }
+  // @TODO UVR
+  //vector<double> turns;
+  //if (m_currentRouterType == RouterType::Vehicle)
+  //{
+  //  turns::TTurnsGeom const & turnsGeom = route.GetTurnsGeometry();
+  //  if (!turnsGeom.empty())
+  //  {
+  //    turns.reserve(turnsGeom.size());
+  //    for (size_t i = 0; i < turnsGeom.size(); i++)
+  //      turns.push_back(turnsGeom[i].m_mercatorDistance);
+  //  }
+  //}
 
   /// @todo Consider a style parameter for the route color.
-  graphics::Color routeColor;
-  if (m_currentRouterType == RouterType::Pedestrian)
-    routeColor = graphics::Color(5, 105, 175, 204);
-  else
-    routeColor = graphics::Color(30, 150, 240, 204);
+  //graphics::Color routeColor;
+  //if (m_currentRouterType == RouterType::Pedestrian)
+  //  routeColor = graphics::Color(5, 105, 175, 204);
+  //else
+  //  routeColor = graphics::Color(30, 150, 240, 204);
 
-  m_bmManager.SetRouteTrack(route.GetPoly(), turnsDistances, routeColor);
+  //m_bmManager.SetRouteTrack(route.GetPoly(), turns, routeColor);
 
-  m_informationDisplay.ResetRouteMatchingInfo();
-  Invalidate();
+  //m_informationDisplay.ResetRouteMatchingInfo();
+  //Invalidate();
 }
 
 void Framework::CheckLocationForRouting(GpsInfo const & info)
@@ -2317,18 +2086,18 @@ void Framework::CheckLocationForRouting(GpsInfo const & info)
   if (!IsRoutingActive())
     return;
 
-  m2::PointD const & position = GetLocationState()->Position();
-  if (m_routingSession.OnLocationPositionChanged(position, info, m_model.GetIndex()) == RoutingSession::RouteNeedRebuild)
-  {
-    auto readyCallback = [this](Route const & route, IRouter::ResultCode code)
-    {
-      if (code == IRouter::NoError)
-        GetPlatform().RunOnGuiThread(bind(&Framework::InsertRoute, this, route));
-    };
+  ///@TODO UVR
+  //m2::PointD const & position = GetLocationState()->Position();
+  //if (m_routingSession.OnLocationPositionChanged(position, info) == RoutingSession::RouteNeedRebuild)
+  //{
+  //  auto readyCallback = [this](Route const & route, IRouter::ResultCode code)
+  //  {
+  //    if (code == IRouter::NoError)
+  //      GetPlatform().RunOnGuiThread(bind(&Framework::InsertRoute, this, route));
+  //  };
 
-    m_routingSession.RebuildRoute(MercatorBounds::FromLatLon(info.m_latitude, info.m_longitude),
-                                  readyCallback, m_progressCallback, 0 /* timeoutSec */);
-  }
+  //  m_routingSession.RebuildRoute(position, readyCallback, m_progressCallback, 0 /* timeoutSec */);
+  //}
 }
 
 void Framework::MatchLocationToRoute(location::GpsInfo & location, location::RouteMatchingInfo & routeMatchingInfo,
@@ -2416,10 +2185,10 @@ void Framework::SetLastUsedRouter(RouterType type)
 
 void Framework::SetRouteStartPoint(m2::PointD const & pt, bool isValid)
 {
-  m_bmManager.SetRouteStartPoint(pt, isValid);
+  //m_bmManager.SetRouteStartPoint(pt);
 }
 
 void Framework::SetRouteFinishPoint(m2::PointD const & pt, bool isValid)
 {
-  m_bmManager.SetRouteFinishPoint(pt, isValid);
+  //m_bmManager.SetRouteFinishPoint(pt);
 }
diff --git a/map/framework.hpp b/map/framework.hpp
index 3f0c957413..a5ae0cd690 100644
--- a/map/framework.hpp
+++ b/map/framework.hpp
@@ -1,5 +1,8 @@
 #pragma once
 
+#include "map/events.hpp"
+#include "drape/oglcontextfactory.hpp"
+#include "drape_frontend/drape_engine.hpp"
 #include "map/feature_vec_model.hpp"
 #include "map/information_display.hpp"
 #include "map/location_state.hpp"
@@ -17,18 +20,6 @@
 #include "map/track.hpp"
 #include "map/country_tree.hpp"
 
-#include "routing/routing_session.hpp"
-
-#include "render/events.hpp"
-#include "render/scales_processor.hpp"
-#ifndef USE_DRAPE
-  #include "render/render_policy.hpp"
-  #include "render/window_handle.hpp"
-#else
-  #include "drape/oglcontextfactory.hpp"
-  #include "drape_frontend/drape_engine.hpp"
-#endif // USE_DRAPE
-
 #include "indexer/data_header.hpp"
 #include "indexer/map_style.hpp"
 
@@ -40,12 +31,6 @@
 #include "platform/country_defines.hpp"
 #include "platform/location.hpp"
 
-#ifndef USE_DRAPE
-  #include "graphics/defines.hpp"
-  #include "graphics/screen.hpp"
-  #include "graphics/color.hpp"
-#endif // USE_DRAPE
-
 #include "geometry/rect2d.hpp"
 #include "geometry/screenbase.hpp"
 
@@ -71,14 +56,10 @@ namespace storage
 class CountryInfoGetter;
 }
 
-namespace gui { class Controller; }
 namespace anim { class Controller; }
 namespace routing { namespace turns{ class Settings; } }
 
 class CountryStatusDisplay;
-class BenchmarkEngine;
-struct FrameImage;
-class CPUDrawer;
 
 /// Uncomment line to make fixed position settings and
 /// build version for screenshots.
@@ -119,7 +100,6 @@ protected:
   search::QuerySaver m_searchQuerySaver;
 
   model::FeaturesFetcher m_model;
-  ScalesProcessor m_scales;
   Navigator m_navigator;
   Animator m_animator;
 
@@ -127,13 +107,7 @@ protected:
 
   typedef vector<BookmarkCategory *>::iterator CategoryIter;
 
-#ifndef USE_DRAPE
-  unique_ptr<RenderPolicy> m_renderPolicy;
-#else
   dp::MasterPointer<df::DrapeEngine> m_drapeEngine;
-#endif
-
-  unique_ptr<CPUDrawer> m_cpuDrawer;
 
   double m_startForegroundTime;
 
@@ -146,7 +120,6 @@ protected:
 
   storage::Storage m_storage;
   storage::CountryTree m_countryTree;
-  unique_ptr<gui::Controller> m_guiController;
   unique_ptr<anim::Controller> m_animController;
   InformationDisplay m_informationDisplay;
 
@@ -166,11 +139,9 @@ protected:
     //return m_timer.ElapsedSeconds();
     return 0.0;
   }
-#ifndef USE_DRAPE
-  void DrawAdditionalInfo(shared_ptr<PaintEvent> const & e);
-#endif // USE_DRAPE
 
-  BenchmarkEngine * m_benchmarkEngine;
+  ///@TODO UVR
+  ///void DrawAdditionalInfo(shared_ptr<PaintEvent> const & e);
 
   BookmarkManager m_bmManager;
   PinClickManager m_balloonManager;
@@ -277,13 +248,8 @@ public:
   void OnCompassUpdate(location::CompassInfo const & info);
   //@}
 
-#ifndef USE_DRAPE
-  void SetRenderPolicy(RenderPolicy * renderPolicy);
-  void InitGuiSubsystem();
-  RenderPolicy * GetRenderPolicy() const;
-#else
   void CreateDrapeEngine(dp::RefPointer<dp::OGLContextFactory> contextFactory, float vs, int w, int h);
-#endif // USE_DRAPE
+  void DestroyDrapeEngine();
 
   void SetMapStyle(MapStyle mapStyle);
   MapStyle GetMapStyle() const;
@@ -311,24 +277,10 @@ public:
   void SetWidgetPivot(InformationDisplay::WidgetType widget, m2::PointD const & pivot);
   m2::PointD GetWidgetSize(InformationDisplay::WidgetType widget) const;
 
-  /// Safe function to get current visual scale.
-  /// Call it when you need do calculate pixel rect (not matter if m_renderPolicy == 0).
-  /// @return 1.0 if m_renderPolicy == 0 (possible for Android).
-  double GetVisualScale() const;
-
   void PrepareToShutdown();
 
   void SetupMeasurementSystem();
 
-#ifndef USE_DRAPE
-  RenderPolicy::TRenderFn DrawModelFn();
-
-  void DrawModel(shared_ptr<PaintEvent> const & e,
-                 ScreenBase const & screen,
-                 m2::RectD const & renderRect,
-                 int baseScale, bool isTilingQuery);
-#endif // USE_DRAPE
-
 private:
   void InitCountryInfoGetter();
   void InitSearchEngine();
@@ -389,9 +341,6 @@ public:
 
   void SetMaxWorldRect();
 
-  void Invalidate(bool doForceUpdate = false);
-  void InvalidateRect(m2::RectD const & rect, bool doForceUpdate = false);
-
   void SaveState();
   bool LoadState();
 
@@ -409,21 +358,6 @@ public:
   /// Set correct viewport, parse API, show balloon.
   bool ShowMapForURL(string const & url);
 
-  bool NeedRedraw() const;
-  void SetNeedRedraw(bool flag);
-
-  inline void XorQueryMaxScaleMode()
-  {
-    m_queryMaxScaleMode = !m_queryMaxScaleMode;
-    Invalidate(true);
-  }
-
-  inline void SetQueryMaxScaleMode(bool mode)
-  {
-    m_queryMaxScaleMode = mode;
-    Invalidate(true);
-  }
-
   /// Get classificator types for nearest features.
   /// @param[in] pxPoint Current touch point in device pixel coordinates.
   void GetFeatureTypes(m2::PointD const & pxPoint, vector<string> & types) const;
@@ -443,14 +377,6 @@ public:
   bool GetVisiblePOI(m2::PointD const & pxPoint, m2::PointD & pxPivot, search::AddressInfo & info, feature::Metadata & metadata) const;
   void FindClosestPOIMetadata(m2::PointD const & pt, feature::Metadata & metadata) const;
 
-#ifndef USE_DRAPE
-  virtual void BeginPaint(shared_ptr<PaintEvent> const & e);
-  /// Function for calling from platform dependent-paint function.
-  virtual void DoPaint(shared_ptr<PaintEvent> const & e);
-
-  virtual void EndPaint(shared_ptr<PaintEvent> const & e);
-#endif // USE_DRAPE
-
 private:
   /// Always check rect in public function for minimal draw scale.
   void CheckMinGlobalRect(m2::RectD & rect) const;
@@ -501,7 +427,7 @@ public:
 
   /// @name Scaling.
   //@{
-  void ScaleToPoint(ScaleToPointEvent const & e, bool anim = true);
+  void ScaleToPoint(ScaleToPointEvent const & e, bool anim = false);
   void ScaleDefault(bool enlarge);
   void Scale(double scale);
 
@@ -514,7 +440,6 @@ public:
   void StopScale(ScaleEvent const & e);
   //@}
 
-  gui::Controller * GetGuiController() const;
   anim::Controller * GetAnimController() const;
 
   Animator & GetAnimator();
@@ -526,8 +451,6 @@ public:
     m_stringsBundle.SetString(name, value);
   }
 
-  bool IsBenchmarking() const;
-
   StringsBundle const & GetStringsBundle();
 
   PinClickManager & GetBalloonManager() { return m_balloonManager; }
@@ -536,7 +459,8 @@ public:
   /// the specified point is loaded
   bool IsCountryLoaded(m2::PointD const & pt) const;
 
-  shared_ptr<location::State> const & GetLocationState() const;
+  ///@TODO UVR
+  //shared_ptr<location::State> const & GetLocationState() const;
   void ActivateUserMark(UserMark const * mark, bool needAnim = true);
   bool HasActiveUserMark() const;
   UserMark const * GetUserMarkWithoutLogging(m2::PointD const & pxPoint, bool isLongPress);
diff --git a/map/information_display.cpp b/map/information_display.cpp
index 33290a17b8..bebee28b39 100644
--- a/map/information_display.cpp
+++ b/map/information_display.cpp
@@ -5,26 +5,13 @@
 #include "map/ruler.hpp"
 #include "map/alfa_animation_task.hpp"
 
-#include "render/drawer.hpp"
-
 #include "anim/task.hpp"
 #include "anim/controller.hpp"
 
-#include "gui/controller.hpp"
-#include "gui/button.hpp"
-#include "gui/cached_text_view.hpp"
-
-#include "graphics/defines.hpp"
-#include "graphics/depth_constants.hpp"
-#include "graphics/display_list.hpp"
-
 #include "platform/platform.hpp"
 
 #include "geometry/transformations.hpp"
 
-
-using namespace graphics;
-
 namespace
 {
   static int const RULLER_X_OFFSET = 6;
@@ -43,7 +30,8 @@ namespace
 InformationDisplay::InformationDisplay(Framework * fw)
   : m_framework(fw)
 {
-  m_fontDesc.m_color = Color(0x4D, 0x4D, 0x4D, 0xCC);
+  ///@TODO UVR
+  //m_fontDesc.m_color = Color(0x4D, 0x4D, 0x4D, 0xCC);
 
   InitRuler(fw);
   InitCountryStatusDisplay(fw);
@@ -61,143 +49,151 @@ InformationDisplay::InformationDisplay(Framework * fw)
 
 void InformationDisplay::InitRuler(Framework * fw)
 {
-  Ruler::Params p;
+  ///@TODO UVR
+//  Ruler::Params p;
 
-  p.m_depth = rulerDepth;
-  p.m_position = EPosAboveLeft;
-  p.m_framework = fw;
+//  p.m_depth = rulerDepth;
+//  p.m_position = EPosAboveLeft;
+//  p.m_framework = fw;
 
-  m_ruler.reset(new Ruler(p));
-  m_ruler->setIsVisible(false);
+//  m_ruler.reset(new Ruler(p));
+//  m_ruler->setIsVisible(false);
 }
 
 void InformationDisplay::InitCountryStatusDisplay(Framework * fw)
 {
-  CountryStatusDisplay::Params p(fw->GetCountryTree().GetActiveMapLayout());
+  ///@TODO UVR
+//  CountryStatusDisplay::Params p(fw->GetCountryTree().GetActiveMapLayout());
 
-  p.m_pivot = m2::PointD(0, 0);
-  p.m_position = EPosCenter;
-  p.m_depth = countryStatusDepth;
+//  p.m_pivot = m2::PointD(0, 0);
+//  p.m_position = EPosCenter;
+//  p.m_depth = countryStatusDepth;
 
-  m_countryStatusDisplay.reset(new CountryStatusDisplay(p));
+//  m_countryStatusDisplay.reset(new CountryStatusDisplay(p));
 }
 
 void InformationDisplay::InitCopyright(Framework * fw)
 {
-  gui::CachedTextView::Params p;
+  ///@TODO UVR
+//  gui::CachedTextView::Params p;
 
-  p.m_depth = rulerDepth;
-  p.m_position = EPosAboveLeft;
-  p.m_pivot = m2::PointD(0, 0);
-  p.m_text = "Map data © OpenStreetMap";
+//  p.m_depth = rulerDepth;
+//  p.m_position = EPosAboveLeft;
+//  p.m_pivot = m2::PointD(0, 0);
+//  p.m_text = "Map data © OpenStreetMap";
 
-  m_copyrightLabel.reset(new gui::CachedTextView(p));
+//  m_copyrightLabel.reset(new gui::CachedTextView(p));
 }
 
 void InformationDisplay::InitCompassArrow(Framework * fw)
 {
-  CompassArrow::Params p;
+  ///@TODO UVR
+//  CompassArrow::Params p;
 
-  p.m_position = EPosCenter;
-  p.m_depth = compassDepth;
-  p.m_pivot = m2::PointD(0, 0);
-  p.m_framework = fw;
+//  p.m_position = EPosCenter;
+//  p.m_depth = compassDepth;
+//  p.m_pivot = m2::PointD(0, 0);
+//  p.m_framework = fw;
 
-  m_compassArrow.reset(new CompassArrow(p));
-  m_compassArrow->setIsVisible(false);
+//  m_compassArrow.reset(new CompassArrow(p));
+//  m_compassArrow->setIsVisible(false);
 }
 
 void InformationDisplay::InitLocationState(Framework * fw)
 {
-  location::State::Params p;
+  ///@TODO UVR
+//  location::State::Params p;
 
-  p.m_position = EPosCenter;
-  p.m_depth = locationDepth;
-  p.m_pivot = m2::PointD(0, 0);
-  p.m_locationAreaColor = Color(30, 150, 240, 20);
-  p.m_framework = fw;
+//  p.m_position = EPosCenter;
+//  p.m_depth = locationDepth;
+//  p.m_pivot = m2::PointD(0, 0);
+//  p.m_locationAreaColor = Color(0x51, 0xA3, 0xDC, 0x46);
+//  p.m_framework = fw;
 
-  m_locationState.reset(new location::State(p));
+//  m_locationState.reset(new location::State(p));
 }
 
 void InformationDisplay::InitDebugLabel()
 {
-  gui::CachedTextView::Params p;
+  ///@TODO UVR
+//  gui::CachedTextView::Params p;
 
-  p.m_depth = debugDepth;
-  p.m_position = EPosAboveRight;
-  p.m_pivot = m2::PointD(0, 0);
+//  p.m_depth = debugDepth;
+//  p.m_position = EPosAboveRight;
+//  p.m_pivot = m2::PointD(0, 0);
 
-  m_debugLabel.reset(new gui::CachedTextView(p));
+//  m_debugLabel.reset(new gui::CachedTextView(p));
 }
 
-void InformationDisplay::setController(gui::Controller * controller)
-{
-  m_controller = controller;
-  m_controller->AddElement(m_countryStatusDisplay);
-  m_controller->AddElement(m_compassArrow);
-  m_controller->AddElement(m_locationState);
-  m_controller->AddElement(m_ruler);
-  m_controller->AddElement(m_debugLabel);
-
-  m_controller->AddElement(m_copyrightLabel);
-  shared_ptr<anim::Task> task(new AlfaAnimationTask(1.0, 0.0, 0.15, 3.0, m_framework));
-  task->AddCallback(anim::Task::EEnded, [this] ()
-                                        {
-                                          m_controller->RemoveElement(m_copyrightLabel);
-                                          m_copyrightLabel.reset();
-                                        });
-
-  m_copyrightLabel->setAnimated([task] ()
-                                {
-                                  AlfaAnimationTask * t = static_cast<AlfaAnimationTask *>(task.get());
-                                  return t->GetCurrentAlfa();
-                                });
-
-  m_framework->GetAnimController()->AddTask(task);
-}
+  ///@TODO UVR
+//void InformationDisplay::setController(gui::Controller * controller)
+//{
+//  m_controller = controller;
+//  m_controller->AddElement(m_countryStatusDisplay);
+//  m_controller->AddElement(m_compassArrow);
+//  m_controller->AddElement(m_locationState);
+//  m_controller->AddElement(m_ruler);
+//  m_controller->AddElement(m_debugLabel);
+
+//  m_controller->AddElement(m_copyrightLabel);
+//  shared_ptr<anim::Task> task(new AlfaAnimationTask(1.0, 0.0, 0.15, 3.0, m_framework));
+//  task->AddCallback(anim::Task::EEnded, [this] ()
+//                                        {
+//                                          m_controller->RemoveElement(m_copyrightLabel);
+//                                          m_copyrightLabel.reset();
+//                                        });
+
+//  m_copyrightLabel->setAnimated([task] ()
+//                                {
+//                                  AlfaAnimationTask * t = static_cast<AlfaAnimationTask *>(task.get());
+//                                  return t->GetCurrentAlfa();
+//                                });
+
+//  m_framework->GetAnimController()->AddTask(task);
+//}
 
 void InformationDisplay::SetWidgetPivotsByDefault(int screenWidth, int screenHeight)
 {
-  double rulerOffsX = RULLER_X_OFFSET;
-  double rulerOffsY = RULLER_Y_OFFSET;
-  double compassOffsX = COMPASS_X_OFFSET;
-  double compassOffsY = COMPASS_Y_OFFSET;
-  m2::RectI const rect = m2::RectI(0, 0, screenWidth, screenHeight);
-
-#ifdef OMIM_OS_ANDROID
-  if (GetPlatform().IsTablet())
-  {
-    rulerOffsX = RULLER_X_OFFSET_L;
-    rulerOffsY = RULLER_Y_OFFSET_L;
-    compassOffsX = COMPASS_X_OFFSET_L;
-    compassOffsY = COMPASS_Y_OFFSET_L;
-  }
-#endif
-
-  double const vs = m_framework->GetVisualScale();
-  m_countryStatusDisplay->setPivot(m2::PointD(rect.Center()));
-
-  m2::PointD const size = m_compassArrow->GetPixelSize();
-  m_compassArrow->setPivot(m2::PointD(compassOffsX * vs + size.x / 2.0,
-                                      rect.maxY() - compassOffsY * vs - size.y / 2.0));
-
-  m_ruler->setPivot(m2::PointD(rect.maxX() - rulerOffsX * vs,
-                               rect.maxY() - rulerOffsY * vs));
-
-  if (m_copyrightLabel)
-  {
-    m_copyrightLabel->setPivot(m2::PointD(rect.maxX() - rulerOffsX * vs,
-                                          rect.maxY() - rulerOffsY * vs));
-  }
 
-  m_debugLabel->setPivot(m2::PointD(rect.minX() + 10,
-                                    rect.minY() + 50 + 5 * vs));
+  ///@TODO UVR
+//  double rulerOffsX = RULLER_X_OFFSET;
+//  double rulerOffsY = RULLER_Y_OFFSET;
+//  double compassOffsX = COMPASS_X_OFFSET;
+//  double compassOffsY = COMPASS_Y_OFFSET;
+//#ifdef OMIM_OS_ANDROID
+//  if (GetPlatform().IsTablet())
+//  {
+//    rulerOffsX = RULLER_X_OFFSET_L;
+//    rulerOffsY = RULLER_Y_OFFSET_L;
+//    compassOffsX = COMPASS_X_OFFSET_L;
+//    compassOffsY = COMPASS_Y_OFFSET_L;
+//  }
+//#endif
+
+//  double const vs = m_framework->GetVisualScale();
+//  m_countryStatusDisplay->setPivot(m2::PointD(rect.Center()));
+
+//  m2::PointD const size = m_compassArrow->GetPixelSize();
+//  m_compassArrow->setPivot(m2::PointD(compassOffsX * vs + size.x / 2.0,
+//                                      rect.maxY() - compassOffsY * vs - size.y / 2.0));
+
+//  m_ruler->setPivot(m2::PointD(rect.maxX() - rulerOffsX * vs,
+//                               rect.maxY() - rulerOffsY * vs));
+
+//  if (m_copyrightLabel)
+//  {
+//    m_copyrightLabel->setPivot(m2::PointD(rect.maxX() - rulerOffsX * vs,
+//                                          rect.maxY() - rulerOffsY * vs));
+//  }
+
+//  m_debugLabel->setPivot(m2::PointD(rect.minX() + 10,
+//                                    rect.minY() + 50 + 5 * vs));
 }
 
 bool InformationDisplay::isCopyrightActive() const
 {
-  return m_copyrightLabel != nullptr;
+  ///@TODO UVR
+  return false;//m_copyrightLabel != nullptr;
 }
 
 void InformationDisplay::enableCopyright(bool doEnable)
@@ -208,30 +204,34 @@ void InformationDisplay::enableCopyright(bool doEnable)
 
 void InformationDisplay::enableRuler(bool doEnable)
 {
-  if (doEnable)
-    m_ruler->AnimateShow();
-  else
-    m_ruler->AnimateHide();
+  ///@TODO UVR
+//  if (doEnable)
+//    m_ruler->AnimateShow();
+//  else
+//    m_ruler->AnimateHide();
 }
 
 bool InformationDisplay::isRulerEnabled() const
 {
-  return m_ruler->isVisible();
+  ///@TODO UVR
+  return false;//m_ruler->isVisible();
 }
 
 void InformationDisplay::setVisualScale(double visualScale)
 {
-  m_fontDesc.m_size = static_cast<uint32_t>(FONT_SIZE * visualScale);
+  ///@TODO UVR
+//  m_fontDesc.m_size = static_cast<uint32_t>(FONT_SIZE * visualScale);
 
-  m_ruler->setFont(gui::Element::EActive, m_fontDesc);
-  m_debugLabel->setFont(gui::Element::EActive, m_fontDesc);
-  if (m_copyrightLabel)
-    m_copyrightLabel->setFont(gui::Element::EActive, m_fontDesc);
+//  m_ruler->setFont(gui::Element::EActive, m_fontDesc);
+//  m_debugLabel->setFont(gui::Element::EActive, m_fontDesc);
+//  if (m_copyrightLabel)
+//    m_copyrightLabel->setFont(gui::Element::EActive, m_fontDesc);
 }
 
 void InformationDisplay::enableDebugInfo(bool doEnable)
 {
-  m_debugLabel->setIsVisible(doEnable);
+  ///@TODO UVR
+  //m_debugLabel->setIsVisible(doEnable);
 }
 
 void InformationDisplay::setDebugInfo(double frameDuration, int currentScale)
@@ -239,45 +239,53 @@ void InformationDisplay::setDebugInfo(double frameDuration, int currentScale)
   ostringstream out;
   out << "Scale : " << currentScale;
 
-  m_debugLabel->setText(out.str());
+  ///@TODO UVR
+  //m_debugLabel->setText(out.str());
 }
 
 void InformationDisplay::enableCompassArrow(bool doEnable)
 {
-  if (doEnable)
-    m_compassArrow->AnimateShow();
-  else
-    m_compassArrow->AnimateHide();
+  ///@TODO UVR
+//  if (doEnable)
+//    m_compassArrow->AnimateShow();
+//  else
+//    m_compassArrow->AnimateHide();
 }
 
 bool InformationDisplay::isCompassArrowEnabled() const
 {
-  return m_compassArrow->isVisible();
+  ///@TODO UVR
+  return false;//m_compassArrow->isVisible();
 }
 
 void InformationDisplay::setCompassArrowAngle(double angle)
 {
-  m_compassArrow->SetAngle(angle);
+  ///@TODO UVR
+  //m_compassArrow->SetAngle(angle);
 }
 
 void InformationDisplay::setEmptyCountryIndex(storage::TIndex const & idx)
 {
-  m_countryStatusDisplay->SetCountryIndex(idx);
+  ///@TODO UVR
+  //m_countryStatusDisplay->SetCountryIndex(idx);
 }
 
 shared_ptr<CountryStatusDisplay> const & InformationDisplay::countryStatusDisplay() const
 {
-  return m_countryStatusDisplay;
+  ///@TODO UVR
+  return nullptr;//m_countryStatusDisplay;
 }
 
 shared_ptr<location::State> const & InformationDisplay::locationState() const
 {
-  return m_locationState;
+  ///@TODO UVR
+  return nullptr; //m_locationState;
 }
 
 void InformationDisplay::measurementSystemChanged()
 {
-  m_ruler->setIsDirtyLayout(true);
+  ///@TODO UVR
+  //m_ruler->setIsDirtyLayout(true);
 }
 
 void InformationDisplay::ResetRouteMatchingInfo()
diff --git a/map/information_display.hpp b/map/information_display.hpp
index da35f58fe3..da3ec8f20e 100644
--- a/map/information_display.hpp
+++ b/map/information_display.hpp
@@ -1,9 +1,5 @@
 #pragma once
 
-#include "gui/button.hpp"
-
-#include "graphics/font_desc.hpp"
-
 #include "storage/index.hpp"
 
 #include "geometry/point2d.hpp"
@@ -19,15 +15,6 @@ namespace location
   class State;
 }
 
-class Drawer;
-
-namespace gui
-{
-  class Button;
-  class Controller;
-  class CachedTextView;
-}
-
 class Framework;
 class CountryStatusDisplay;
 class CompassArrow;
@@ -38,16 +25,19 @@ class Ruler;
 class InformationDisplay
 {
   Framework * m_framework;
-  graphics::FontDesc m_fontDesc;
+  ///@TODO UVR
+  //graphics::FontDesc m_fontDesc;
 
   shared_ptr<Ruler> m_ruler;
-  gui::Controller * m_controller;
+  ///@TODO UVR
+  //gui::Controller * m_controller;
 
   shared_ptr<CountryStatusDisplay> m_countryStatusDisplay;
   shared_ptr<CompassArrow> m_compassArrow;
   shared_ptr<location::State> m_locationState;
-  shared_ptr<gui::CachedTextView> m_debugLabel;
-  shared_ptr<gui::CachedTextView> m_copyrightLabel;
+  ///@TODO UVR
+  //shared_ptr<gui::CachedTextView> m_debugLabel;
+  //shared_ptr<gui::CachedTextView> m_copyrightLabel;
 
   void InitRuler(Framework * fw);
   void InitDebugLabel();
@@ -67,14 +57,9 @@ public:
   };
 
   InformationDisplay(Framework * framework);
+  //void setController(gui::Controller * controller);
 
-  void setController(gui::Controller * controller);
-  /*!
-   * \brief SetWidgetPivotsByDefault sets the default pivot points for all the widgets on the map.
-   * The pivot points can be overridden by a call of SetWidgetPivot()
-   * after Framework::OnSize() call.
-   */
-  void SetWidgetPivotsByDefault(int screenWidth, int screenHeight);
+  void setDisplayRect(m2::RectI const & rect);
   void setVisualScale(double visualScale);
 
   bool isCopyrightActive() const;
diff --git a/map/location_state.cpp b/map/location_state.cpp
index 00f7e333d3..00dce157e8 100644
--- a/map/location_state.cpp
+++ b/map/location_state.cpp
@@ -3,19 +3,11 @@
 #include "map/framework.hpp"
 #include "map/move_screen_task.hpp"
 
-#ifndef USE_DRAPE
-#include "graphics/display_list.hpp"
-#include "graphics/icon.hpp"
-#include "graphics/depth_constants.hpp"
-#endif // USE_DRAPE
-
 #include "anim/controller.hpp"
 #include "anim/task.hpp"
 #include "anim/angle_interpolation.hpp"
 #include "anim/segment_interpolation.hpp"
 
-#include "gui/controller.hpp"
-
 #include "indexer/mercator.hpp"
 #include "indexer/scales.hpp"
 
@@ -105,12 +97,14 @@ public:
     {
       m_hasPendingAnimation = false;
       SetParams(m_pendingDstPos, m_pendingAngle);
-      m_fw->Invalidate();
+      ///@TODO UVR
+      //m_fw->Invalidate();
     }
     else if (m_idleFrames > 0)
     {
       --m_idleFrames;
-      m_fw->Invalidate();
+      ///@TODO UVR
+      //m_fw->Invalidate();
     }
   }
 
@@ -185,7 +179,8 @@ private:
 
     m_fw->SetViewportCenter(currentPosition + rotateVector);
     m_fw->GetNavigator().SetAngle(currentAngle);
-    m_fw->Invalidate();
+    ///@TODO UVR
+    //m_fw->Invalidate();
   }
 
   void SetParams(m2::PointD const & dstPos, double dstAngle)
@@ -251,13 +246,11 @@ string const LocationStateMode = "LastLocationStateMode";
 }
 
 State::Params::Params()
-  : m_locationAreaColor(0, 0, 0, 0),
-    m_framework(0)
+  : m_framework(0)
 {}
 
 State::State(Params const & p)
-  : TBase(p),
-    m_modeInfo(Follow),
+  : m_modeInfo(Follow),
     m_errorRadius(0),
     m_position(0, 0),
     m_drawDirection(0.0),
@@ -266,7 +259,6 @@ State::State(Params const & p)
     m_routeMatchingInfo(),
     m_currentSlotID(0)
 {
-  m_locationAreaColor = p.m_locationAreaColor;
   m_framework = p.m_framework;
 
   int mode = 0;
@@ -277,7 +269,8 @@ State::State(Params const & p)
   if (Settings::Get("IsBenchmarking", isBench) && isBench)
     m_modeInfo = UnknownPosition;
 
-  setIsVisible(false);
+  ///@TODO UVR
+  //setIsVisible(false);
 }
 
 m2::PointD const & State::Position() const
@@ -393,8 +386,9 @@ void State::TurnOff()
 {
   StopLocationFollow();
   SetModeInfo(UnknownPosition);
-  setIsVisible(false);
-  invalidate();
+  ///@TODO UVR
+  //setIsVisible(false);
+  //invalidate();
 }
 
 void State::OnLocationUpdate(location::GpsInfo const & info, bool isNavigable, location::RouteMatchingInfo const & routeMatchingInfo)
@@ -402,7 +396,8 @@ void State::OnLocationUpdate(location::GpsInfo const & info, bool isNavigable, l
   Assign(info, isNavigable);
   m_routeMatchingInfo = routeMatchingInfo;
 
-  setIsVisible(true);
+  ///@TODO UVR
+  //setIsVisible(true);
 
   if (GetMode() == PendingPosition)
   {
@@ -413,7 +408,8 @@ void State::OnLocationUpdate(location::GpsInfo const & info, bool isNavigable, l
     AnimateFollow();
 
   CallPositionChangedListeners(m_position);
-  invalidate();
+  ///@TODO UVR
+  //invalidate();
 }
 
 void State::OnCompassUpdate(location::CompassInfo const & info)
@@ -421,7 +417,8 @@ void State::OnCompassUpdate(location::CompassInfo const & info)
   if (Assign(info))
   {
     AnimateFollow();
-    invalidate();
+    ///@TODO UVR
+    //invalidate();
   }
 }
 
@@ -470,184 +467,41 @@ void State::InvalidatePosition()
     SetModeInfo(ChangeMode(m_modeInfo, UnknownPosition));
     SetModeInfo(ChangeMode(m_modeInfo, PendingPosition));
     m_afterPendingMode = currentMode;
-    setIsVisible(true);
+    ///@TODO UVR
+    //setIsVisible(true);
   }
   else if (currentMode == UnknownPosition)
   {
     m_afterPendingMode = Follow;
-    setIsVisible(false);
+    ///@TODO UVR
+    //setIsVisible(false);
   }
 
-  invalidate();
+  ///@TODO UVR
+  //invalidate();
 }
 
 void State::cache()
 {
-#ifndef USE_DRAPE
-  CachePositionArrow();
-  CacheRoutingArrow();
-  CacheLocationMark();
-
-  m_controller->GetCacheScreen()->completeCommands();
-#endif // USE_DRAPE
 }
 
 void State::purge()
 {
-#ifndef USE_DRAPE
-  m_positionArrow.reset();
-  m_locationMarkDL.reset();
-  m_positionMarkDL.reset();
-  m_routingArrow.reset();
-#endif // USE_DRAPE
 }
 
 void State::update()
 {
-  if (isVisible() && IsModeHasPosition())
-  {
-    m2::PointD const pxPosition = m_framework->GetNavigator().GtoP(Position());
-    setPivot(pxPosition, false);
+  ///@TODO UVR
+//  if (isVisible() && IsModeHasPosition())
+//  {
+//    m2::PointD const pxPosition = m_framework->GetNavigator().GtoP(Position());
+//    setPivot(pxPosition, false);
 
-    if (m_animTask)
-      static_cast<RotateAndFollowAnim *>(m_animTask.get())->Update();
-  }
+//    if (m_animTask)
+//      static_cast<RotateAndFollowAnim *>(m_animTask.get())->Update();
+//  }
 }
 
-void State::draw(graphics::OverlayRenderer * r,
-                 math::Matrix<double, 3, 3> const & m) const
-{
-#ifndef USE_DRAPE
-  if (!IsModeHasPosition() || !isVisible())
-    return;
-
-  checkDirtyLayout();
-
-  m2::PointD const pxPosition = m_framework->GetNavigator().GtoP(Position());
-  double const pxErrorRadius = pxPosition.Length(
-        m_framework->GetNavigator().GtoP(Position() + m2::PointD(m_errorRadius, 0.0)));
-
-  double const drawScale = pxErrorRadius / s_cacheRadius;
-  m2::PointD const & pivotPosition = GetPositionForDraw();
-
-  math::Matrix<double, 3, 3> locationDrawM = math::Shift(
-                                               math::Scale(
-                                                 math::Identity<double, 3>(),
-                                                 drawScale,
-                                                 drawScale),
-                                               pivotPosition);
-
-  math::Matrix<double, 3, 3> const drawM = locationDrawM * m;
-  // draw error sector
-  r->drawDisplayList(m_locationMarkDL.get(), drawM);
-
-  // if we know look direction than we draw arrow
-  if (IsDirectionKnown())
-  {
-    double rotateAngle = m_drawDirection + GetModelView().GetAngle();
-
-    math::Matrix<double, 3, 3> compassDrawM = math::Shift(
-                                                math::Rotate(
-                                                  math::Identity<double, 3>(),
-                                                  rotateAngle),
-                                                pivotPosition);
-
-    if (!IsInRouting())
-      r->drawDisplayList(m_positionArrow.get(), compassDrawM * m);
-    else
-      r->drawDisplayList(m_routingArrow.get(), compassDrawM * m);
-  }
-  else
-    r->drawDisplayList(m_positionMarkDL.get(), drawM);
-#endif // USE_DRAPE
-}
-
-#ifndef USE_DRAPE
-void State::CachePositionArrow()
-{
-  m_positionArrow.reset();
-  m_positionArrow.reset(m_controller->GetCacheScreen()->createDisplayList());
-  CacheArrow(m_positionArrow.get(), "current-position-compas");
-}
-
-void State::CacheRoutingArrow()
-{
-  m_routingArrow.reset();
-  m_routingArrow.reset(m_controller->GetCacheScreen()->createDisplayList());
-  CacheArrow(m_routingArrow.get(), "current-routing-compas");
-}
-
-void State::CacheLocationMark()
-{
-  graphics::Screen * cacheScreen = m_controller->GetCacheScreen();
-
-  m_locationMarkDL.reset();
-  m_locationMarkDL.reset(cacheScreen->createDisplayList());
-
-  m_positionMarkDL.reset();
-  m_positionMarkDL.reset(cacheScreen->createDisplayList());
-
-  cacheScreen->beginFrame();
-  cacheScreen->setDisplayList(m_locationMarkDL.get());
-
-  cacheScreen->fillSector(m2::PointD(0, 0),
-                          0, 2.0 * math::pi,
-                          s_cacheRadius,
-                          m_locationAreaColor,
-                          graphics::locationFaultDepth);
-
-  cacheScreen->setDisplayList(m_positionMarkDL.get());
-  cacheScreen->drawSymbol(m2::PointD(0, 0),
-                          "current-position",
-                          graphics::EPosCenter,
-                          graphics::locationDepth);
-
-  cacheScreen->setDisplayList(0);
-
-  cacheScreen->endFrame();
-}
-
-void State::CacheArrow(graphics::DisplayList * dl, const string & iconName)
-{
-  graphics::Screen * cacheScreen = m_controller->GetCacheScreen();
-  graphics::Icon::Info info(iconName);
-
-  graphics::Resource const * res = cacheScreen->fromID(cacheScreen->findInfo(info));
-  m2::RectU const rect = res->m_texRect;
-  m2::PointD const halfArrowSize(rect.SizeX() / 2.0, rect.SizeY() / 2.0);
-
-  cacheScreen->beginFrame();
-  cacheScreen->setDisplayList(dl);
-
-  m2::PointD coords[4] =
-  {
-    m2::PointD(-halfArrowSize.x, -halfArrowSize.y),
-    m2::PointD(-halfArrowSize.x,  halfArrowSize.y),
-    m2::PointD( halfArrowSize.x, -halfArrowSize.y),
-    m2::PointD( halfArrowSize.x,  halfArrowSize.y)
-  };
-
-  m2::PointF const normal(0.0, 0.0);
-  shared_ptr<graphics::gl::BaseTexture> texture = cacheScreen->pipeline(res->m_pipelineID).texture();
-
-  m2::PointF texCoords[4] =
-  {
-    texture->mapPixel(m2::PointF(rect.minX(), rect.minY())),
-    texture->mapPixel(m2::PointF(rect.minX(), rect.maxY())),
-    texture->mapPixel(m2::PointF(rect.maxX(), rect.minY())),
-    texture->mapPixel(m2::PointF(rect.maxX(), rect.maxY()))
-  };
-
-  cacheScreen->addTexturedStripStrided(coords, sizeof(m2::PointD),
-                                       &normal, 0,
-                                       texCoords, sizeof(m2::PointF),
-                                       4, graphics::locationDepth, res->m_pipelineID);
-  cacheScreen->setDisplayList(0);
-  cacheScreen->endFrame();
-}
-
-#endif // USE_DRAPE
-
 bool State::IsRotationActive() const
 {
   return IsDirectionKnown();
@@ -725,7 +579,8 @@ void State::SetModeInfo(uint16_t modeInfo, bool callListeners)
       CallStateModeListeners();
 
     AnimateStateTransition(oldMode, newMode);
-    invalidate();
+    ///@TODO UVR
+    //invalidate();
   }
 }
 
@@ -745,9 +600,11 @@ ScreenBase const & State::GetModelView() const
 
 m2::PointD const State::GetRaFModeDefaultPxBind() const
 {
-  m2::RectD const & pixelRect = GetModelView().PixelRect();
-  return m2::PointD(pixelRect.Center().x,
-                    pixelRect.maxY() - POSITION_Y_OFFSET * visualScale());
+  return m2::PointD();
+  ///@TODO UVR
+//  m2::RectD const & pixelRect = GetModelView().PixelRect();
+//  return m2::PointD(pixelRect.Center().x,
+//                    pixelRect.maxY() - POSITION_Y_OFFSET * visualScale());
 }
 
 void State::StopCompassFollowing()
@@ -851,7 +708,7 @@ void State::OnCompassTaped()
   AnimateFollow();
 }
 
-void State::OnSize(m2::RectD const & /*oldPixelRect*/)
+void State::OnSize()
 {
   if (GetMode() == RotateAndFollow)
   {
@@ -955,7 +812,9 @@ m2::PointD const State::GetPositionForDraw() const
   if (m_animTask != nullptr)
     return m_framework->GtoP(static_cast<RotateAndFollowAnim *>(m_animTask.get())->GetPositionForDraw());
 
-  return pivot();
+  return m2::PointD();
+  ///@TODO UVR
+  //return pivot();
 }
 
 }
diff --git a/map/location_state.hpp b/map/location_state.hpp
index 631acbf7b1..a62fde9772 100644
--- a/map/location_state.hpp
+++ b/map/location_state.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "gui/element.hpp"
-
 #include "geometry/point2d.hpp"
 
 #include "base/timer.hpp"
@@ -15,11 +13,9 @@
 #include "std/unique_ptr.hpp"
 #include "std/map.hpp"
 
-
 class Framework;
 class ScreenBase;
 
-namespace graphics { class DisplayList; }
 namespace anim { class Task;}
 
 namespace location
@@ -30,14 +26,14 @@ namespace location
   // Class, that handles position and compass updates,
   // centers, scales and rotates map according to this updates
   // and draws location and compass marks.
-  class State : public gui::Element
+  class State
   {
-    typedef gui::Element TBase;
 
   public:
-    struct Params : TBase::Params
+    struct Params
     {
-      graphics::Color m_locationAreaColor;
+      ///@TODO UVR
+      //graphics::Color m_locationAreaColor;
       Framework * m_framework;
       Params();
     };
@@ -100,7 +96,7 @@ namespace location
 
     void OnCompassTaped();
 
-    void OnSize(m2::RectD const & oldPixelRect);
+    void OnSize();
 
     /// @name GPS location updates routine.
     //@{
@@ -114,9 +110,9 @@ namespace location
 
     /// @name Override from graphics::OverlayElement and gui::Element.
     //@{
-    virtual m2::RectD GetBoundRect() const { return m2::RectD(); }
+    ///@TODO UVR
+    //virtual m2::RectD GetBoundRect() const { return m2::RectD(); }
 
-    void draw(graphics::OverlayRenderer * r, math::Matrix<double, 3, 3> const & m) const;
     bool hitTest(m2::PointD const & /*pt*/) const { return false; }
 
     void cache();
@@ -133,14 +129,6 @@ namespace location
     void CallPositionChangedListeners(m2::PointD const & pt);
     void CallStateModeListeners();
 
-#ifndef USE_DRAPE
-    void CachePositionArrow();
-    void CacheRoutingArrow();
-    void CacheLocationMark();
-
-    void CacheArrow(graphics::DisplayList * dl, string const & iconName);
-#endif // USE_DRAPE
-
     bool IsRotationActive() const;
     bool IsInRouting() const;
     bool IsRoutingFollowingDisabled() const;
@@ -192,13 +180,6 @@ namespace location
 
     /// @name Compass Rendering Parameters
     //@{
-#ifndef USE_DRAPE
-    unique_ptr<graphics::DisplayList> m_positionArrow;
-    unique_ptr<graphics::DisplayList> m_locationMarkDL;
-    unique_ptr<graphics::DisplayList> m_positionMarkDL;
-    unique_ptr<graphics::DisplayList> m_routingArrow;
-#endif // USE_DRAPE
-    graphics::Color m_locationAreaColor;
     //@}
 
     /// @name Rotation mode animation
diff --git a/map/map_tests/bookmarks_test.cpp b/map/map_tests/bookmarks_test.cpp
index 38184fe6ac..c7b051c275 100644
--- a/map/map_tests/bookmarks_test.cpp
+++ b/map/map_tests/bookmarks_test.cpp
@@ -637,10 +637,10 @@ UNIT_TEST(TrackParsingTest_1)
   TEST_EQUAL(cat->GetTracksCount(), 4, ());
 
   string names[4] = { "Option1", "Pakkred1", "Pakkred2", "Pakkred3"};
-  graphics::Color col[4] = {graphics::Color(230, 0, 0, 255),
-                            graphics::Color(171, 230, 0, 255),
-                            graphics::Color(0, 230, 117, 255),
-                            graphics::Color(0, 59, 230, 255)};
+  dp::Color col[4] = {dp::Color(230, 0, 0, 255),
+                      dp::Color(171, 230, 0, 255),
+                      dp::Color(0, 230, 117, 255),
+                      dp::Color(0, 59, 230, 255)};
   double length[4] = {3525.46839061, 27174.11393166, 27046.0456586, 23967.35765800};
 
   for (size_t i = 0; i < ARRAY_SIZE(names); ++i)
@@ -662,6 +662,6 @@ UNIT_TEST(TrackParsingTest_2)
   TEST_EQUAL(cat->GetTracksCount(), 1, ());
   Track const * track = cat->GetTrack(0);
   TEST_EQUAL(track->GetName(), "XY", ());
-  TEST_EQUAL(track->GetMainColor(), graphics::Color(57, 255, 32, 255), ());
+  TEST_EQUAL(track->GetMainColor(), dp::Color(57, 255, 32, 255), ());
 }
 
diff --git a/map/map_tests/map_tests.pro b/map/map_tests/map_tests.pro
index 57c4972ff2..713e978a5e 100644
--- a/map/map_tests/map_tests.pro
+++ b/map/map_tests/map_tests.pro
@@ -6,7 +6,7 @@ CONFIG -= app_bundle
 TEMPLATE = app
 
 ROOT_DIR = ../..
-DEPENDENCIES = map render gui routing search storage graphics indexer platform anim geometry coding base \
+DEPENDENCIES = map drape_frontend routing search storage drape indexer platform geometry coding base \
                freetype fribidi expat protobuf tomcrypt jansson osrm stats_client minizip succinct
 
 DEPENDENCIES *= opening_hours
diff --git a/map/map_tests/mwm_url_tests.cpp b/map/map_tests/mwm_url_tests.cpp
index 8f295fded1..5b6d5f26bd 100644
--- a/map/map_tests/mwm_url_tests.cpp
+++ b/map/map_tests/mwm_url_tests.cpp
@@ -35,8 +35,7 @@ namespace
     m2::RectD GetViewport()
     {
       m2::RectD rect;
-      ScalesProcessor scales;
-      m_api.GetViewportRect(scales, rect);
+      m_api.GetViewportRect(rect);
       return rect;
     }
     string const & GetAppTitle() { return m_api.GetAppTitle(); }
diff --git a/map/map_tests/navigator_test.cpp b/map/map_tests/navigator_test.cpp
index cadeccbcbf..d35c769a5a 100644
--- a/map/map_tests/navigator_test.cpp
+++ b/map/map_tests/navigator_test.cpp
@@ -30,8 +30,7 @@
 
 UNIT_TEST(Navigator_Scale2Points)
 {
-  ScalesProcessor scales;
-  Navigator navigator(scales);
+  Navigator navigator;
 
   navigator.OnSize(0, 0, 200, 100);
   navigator.SetFromRect(m2::AnyRectD(m2::RectD(0, 0, 8, 4)));
@@ -69,8 +68,7 @@ namespace
 
 UNIT_TEST(Navigator_G2P_P2G)
 {
-  ScalesProcessor scales;
-  Navigator navigator(scales);
+  Navigator navigator;
 
   // Initialize.
   navigator.OnSize(0, 0, 200, 100);
diff --git a/map/mwm_url.cpp b/map/mwm_url.cpp
index 8b2bc68f57..0f3479e2aa 100644
--- a/map/mwm_url.cpp
+++ b/map/mwm_url.cpp
@@ -1,6 +1,6 @@
-#include "mwm_url.hpp"
+#include "map/mwm_url.hpp"
 
-#include "render/scales_processor.hpp"
+#include "drape_frontend/visual_params.hpp"
 
 #include "indexer/mercator.hpp"
 #include "indexer/scales.hpp"
@@ -174,14 +174,14 @@ void ParsedMapApi::Reset()
   m_goBackOnBalloonClick = false;
 }
 
-bool ParsedMapApi::GetViewportRect(ScalesProcessor const & scales, m2::RectD & rect) const
+bool ParsedMapApi::GetViewportRect(m2::RectD & rect) const
 {
   ASSERT(m_controller != NULL, ());
   size_t markCount = m_controller->GetUserMarkCount();
   if (markCount == 1 && m_zoomLevel >= 1)
   {
     double zoom = min(static_cast<double>(scales::GetUpperComfortScale()), m_zoomLevel);
-    rect = scales.GetRectForDrawScale(zoom, m_controller->GetUserMark(0)->GetOrg());
+    rect = df::GetRectForDrawScale(zoom, m_controller->GetUserMark(0)->GetOrg());
     return true;
   }
   else
diff --git a/map/mwm_url.hpp b/map/mwm_url.hpp
index a0e71ee9dd..36495bc930 100644
--- a/map/mwm_url.hpp
+++ b/map/mwm_url.hpp
@@ -39,7 +39,7 @@ public:
   bool GoBackOnBalloonClick() const { return m_goBackOnBalloonClick; }
 
   /// @name Used in settings map viewport after invoking API.
-  bool GetViewportRect(ScalesProcessor const & scales, m2::RectD & rect) const;
+  bool GetViewportRect(m2::RectD & rect) const;
   UserMark const * GetSinglePoint() const;
 
 private:
diff --git a/map/navigator.cpp b/map/navigator.cpp
index b32a723df6..ff46c54999 100644
--- a/map/navigator.cpp
+++ b/map/navigator.cpp
@@ -1,5 +1,7 @@
 #include "map/navigator.hpp"
 
+#include "drape_frontend/visual_params.hpp"
+
 #include "indexer/scales.hpp"
 
 #include "platform/settings.hpp"
@@ -25,15 +27,14 @@ namespace
   }
 }
 
-Navigator::Navigator(ScalesProcessor const & scales)
-  : m_scales(scales),
-    m_InAction(false)
+Navigator::Navigator()
+  : m_InAction(false)
 {
 }
 
 void Navigator::SetFromRects(m2::AnyRectD const & glbRect, m2::RectD const & pxRect)
 {
-  m2::RectD const & worldR = m_scales.GetWorldRect();
+  m2::RectD const & worldR = df::GetWorldRect();
 
   m_Screen.SetFromRects(glbRect, pxRect);
   m_Screen = ScaleInto(m_Screen, worldR);
@@ -47,7 +48,7 @@ void Navigator::SetFromRects(m2::AnyRectD const & glbRect, m2::RectD const & pxR
 
 void Navigator::SetFromRect(m2::AnyRectD const & r)
 {
-  m2::RectD const & worldR = m_scales.GetWorldRect();
+  m2::RectD const & worldR = df::GetWorldRect();
 
   m_Screen.SetFromRect(r);
   m_Screen = ScaleInto(m_Screen, worldR);
@@ -81,7 +82,7 @@ double Navigator::ComputeMoveSpeed(m2::PointD const & /*p0*/, m2::PointD const &
 
 void Navigator::OnSize(int x0, int y0, int w, int h)
 {
-  m2::RectD const & worldR = m_scales.GetWorldRect();
+  m2::RectD const & worldR = df::GetWorldRect();
 
   m_Screen.OnSize(x0, y0, w, h);
   m_Screen = ShrinkAndScaleInto(m_Screen, worldR);
@@ -123,8 +124,6 @@ ScreenBase const Navigator::ShrinkInto(ScreenBase const & screen, m2::RectD boun
 {
   ReduceRectHack(boundRect);
 
-//  ASSERT ( CanShrinkInto(screen, boundRect), () );
-
   ScreenBase res = screen;
 
   m2::RectD clipRect = res.ClipRect();
@@ -144,18 +143,6 @@ ScreenBase const Navigator::ShrinkInto(ScreenBase const & screen, m2::RectD boun
   return res;
 }
 
-bool Navigator::CanRotateInto(ScreenBase const & screen, m2::RectD const & boundRect)
-{
-  /// @todo
-  return false;
-}
-
-ScreenBase const Navigator::RotateInto(ScreenBase const & screen, m2::RectD const & boundRect)
-{
-  /// @todo
-  return screen;
-}
-
 ScreenBase const Navigator::ScaleInto(ScreenBase const & screen, m2::RectD boundRect)
 {
   ReduceRectHack(boundRect);
@@ -319,7 +306,7 @@ void Navigator::DoDrag(m2::PointD const & pt, double /*timeInSec*/)
   if (m_LastPt1 == pt)
     return;
 
-  ScreenBase const s = ShrinkInto(m_StartScreen, m_scales.GetWorldRect());
+  ScreenBase const s = ShrinkInto(m_StartScreen, df::GetWorldRect());
 
   double dx = pt.x - m_StartPt1.x;
   double dy = pt.y - m_StartPt1.y;
@@ -487,20 +474,20 @@ shared_ptr<anim::Task> Navigator::ScaleToPointAnim(m2::PointD const & pt, double
 bool Navigator::CheckMinScale(ScreenBase const & screen) const
 {
   m2::RectD const & r = screen.ClipRect();
-  m2::RectD const & worldR = m_scales.GetWorldRect();
+  m2::RectD const & worldR = df::GetWorldRect();
 
   return (r.SizeX() <= worldR.SizeX() || r.SizeY() <= worldR.SizeY());
 }
 
 bool Navigator::CheckMaxScale(ScreenBase const & screen) const
 {
-  return (m_scales.GetDrawTileScale(screen) <= scales::GetUpperStyleScale());
+  return (df::GetDrawTileScale(screen) <= scales::GetUpperStyleScale());
 }
 
 bool Navigator::CheckBorders(ScreenBase const & screen) const
 {
   m2::RectD const & r = screen.ClipRect();
-  m2::RectD const & worldR = m_scales.GetWorldRect();
+  m2::RectD const & worldR = df::GetWorldRect();
 
   return (r.IsRectInside(worldR) || worldR.IsRectInside(r));
 }
@@ -521,7 +508,7 @@ bool Navigator::ScaleImpl(m2::PointD const & newPt1, m2::PointD const & newPt2,
   if (!skipMinScaleAndBordersCheck && !CheckMinScale(tmp))
     return false;
 
-  m2::RectD const & worldR = m_scales.GetWorldRect();
+  m2::RectD const & worldR = df::GetWorldRect();
 
   if (!skipMinScaleAndBordersCheck && !CheckBorders(tmp))
   {
@@ -650,5 +637,5 @@ bool Navigator::Update(double timeInSec)
 
 int Navigator::GetDrawScale() const
 {
-  return m_scales.GetDrawTileScale(m_Screen);
+  return df::GetDrawTileScale(m_Screen);
 }
diff --git a/map/navigator.hpp b/map/navigator.hpp
index 7739c771c6..8c33800657 100644
--- a/map/navigator.hpp
+++ b/map/navigator.hpp
@@ -1,5 +1,4 @@
 #pragma once
-#include "render/scales_processor.hpp"
 
 #include "anim/task.hpp"
 
@@ -14,7 +13,7 @@
 class Navigator
 {
 public:
-  Navigator(ScalesProcessor const & scales);
+  Navigator();
 
   void SetFromRect(m2::AnyRectD const & r);
   void CenterViewport(m2::PointD const & p);
@@ -72,8 +71,6 @@ public:
   int GetDrawScale() const;
 
 private:
-  ScalesProcessor const & m_scales;
-
   bool CheckMinScale(ScreenBase const & screen) const;
   bool CheckMaxScale(ScreenBase const & screen) const;
   bool CheckBorders(ScreenBase const & screen) const;
@@ -81,9 +78,6 @@ private:
   static bool CanShrinkInto(ScreenBase const & screen, m2::RectD const & boundRect);
   static ScreenBase const ShrinkInto(ScreenBase const & screen, m2::RectD boundRect);
 
-  static bool CanRotateInto(ScreenBase const & screen, m2::RectD const & boundRect);
-  static ScreenBase const RotateInto(ScreenBase const & screen, m2::RectD const & boundRect);
-
   static ScreenBase const ScaleInto(ScreenBase const & screen, m2::RectD boundRect);
   static ScreenBase const ShrinkAndScaleInto(ScreenBase const & screen, m2::RectD boundRect);
 
diff --git a/map/pin_click_manager.cpp b/map/pin_click_manager.cpp
index 3bf184df56..733743d4b3 100644
--- a/map/pin_click_manager.cpp
+++ b/map/pin_click_manager.cpp
@@ -6,23 +6,16 @@
 #include "anim/task.hpp"
 #include "anim/controller.hpp"
 
-#include "graphics/depth_constants.hpp"
-#include "graphics/opengl/base_texture.hpp"
-#include "graphics/display_list.hpp"
-#include "graphics/icon.hpp"
-
 #include "geometry/transformations.hpp"
 
-#include "gui/controller.hpp"
-
-
 PinClickManager::PinClickManager(Framework & f)
   : m_f(f)
 {}
 
 void PinClickManager::Hide()
 {
-  m_f.Invalidate();
+  ///@TODO UVR
+  //m_f.Invalidate();
 }
 
 void PinClickManager::OnShowMark(UserMark const * mark)
@@ -37,13 +30,15 @@ void PinClickManager::SetBalloonVisible(bool isVisible)
   if (!isVisible && m_f.HasActiveUserMark())
     OnDismiss();
 
-  m_f.Invalidate();
+  ///@TODO UVR
+  //m_f.Invalidate();
 }
 
 void PinClickManager::RemovePin()
 {
   m_f.ActivateUserMark(NULL);
-  m_f.Invalidate();
+  ///@TODO UVR
+  //m_f.Invalidate();
 }
 
 void PinClickManager::Dismiss()
diff --git a/map/pin_click_manager.hpp b/map/pin_click_manager.hpp
index 2750432607..ef307fbf68 100644
--- a/map/pin_click_manager.hpp
+++ b/map/pin_click_manager.hpp
@@ -1,8 +1,6 @@
 #pragma once
 #include "map/bookmark.hpp"
 
-#include "graphics/defines.hpp"
-
 #include "geometry/point2d.hpp"
 
 #include "std/function.hpp"
@@ -27,7 +25,6 @@ class PinClickManager
 public:
   PinClickManager(Framework & f);
 
-  void RenderPolicyCreated(graphics::EDensity density) {}
   void LocationChanged(location::GpsInfo const & info) {}
 
   void OnShowMark(UserMark const * mark);
diff --git a/map/rotate_screen_task.cpp b/map/rotate_screen_task.cpp
index 3a8cb49ff8..65c59ef2ed 100644
--- a/map/rotate_screen_task.cpp
+++ b/map/rotate_screen_task.cpp
@@ -19,7 +19,8 @@ void RotateScreenTask::OnStep(double ts)
   anim::AngleInterpolation::OnStep(ts);
   Navigator & nav = m_framework->GetNavigator();
   nav.SetAngle(nav.Screen().GetAngle() + m_outAngle - prevAngle);
-  m_framework->Invalidate();
+  ///@TODO UVR
+  //m_framework->Invalidate();
 }
 
 void RotateScreenTask::OnEnd(double ts)
@@ -27,7 +28,8 @@ void RotateScreenTask::OnEnd(double ts)
   anim::AngleInterpolation::OnEnd(ts);
   Navigator & nav = m_framework->GetNavigator();
   nav.SetAngle(m_outAngle);
-  m_framework->Invalidate();
+  ///@TODO UVR
+  //m_framework->Invalidate();
 }
 
 bool RotateScreenTask::IsVisual() const
diff --git a/map/ruler.cpp b/map/ruler.cpp
index 7704db5a25..e539d3eb97 100644
--- a/map/ruler.cpp
+++ b/map/ruler.cpp
@@ -7,23 +7,12 @@
 #include "platform/measurement_utils.hpp"
 #include "platform/settings.hpp"
 
-#include "gui/controller.hpp"
-
-#include "graphics/glyph.hpp"
-#include "graphics/brush.hpp"
-#include "graphics/screen.hpp"
-#include "graphics/display_list.hpp"
-#include "graphics/uniforms_holder.hpp"
-
 #include "indexer/mercator.hpp"
 
 #include "geometry/transformations.hpp"
 
 #include "base/string_utils.hpp"
 
-
-using namespace graphics;
-
 namespace
 {
   static const int RulerHeight = 2;
@@ -104,7 +93,7 @@ Ruler::RulerFrame::RulerFrame(Framework & f, const Ruler::RulerFrame::frame_end_
 
 
 Ruler::RulerFrame::RulerFrame(const Ruler::RulerFrame & other, const Ruler::RulerFrame::frame_end_fn & fn)
-  : m_f(other.m_f), m_dl(other.m_dl), m_textDL(other.m_textDL)
+  : m_f(other.m_f)
 {
   m_textLengthInPx = other.m_textLengthInPx;
   m_scale = other.m_scale;
@@ -128,140 +117,139 @@ Ruler::RulerFrame::~RulerFrame()
 
 bool Ruler::RulerFrame::IsValid() const
 {
-  return m_dl != NULL && m_textDL != NULL;
-}
-
-void Ruler::RulerFrame::Cache(const string & text, FontDesc const & f)
-{
-  gui::Controller * controller = m_f.GetGuiController();
-  Screen * cs = controller->GetCacheScreen();
-  double const k = m_f.GetVisualScale();
-
-  // Create solid line DL.
-  if (m_dl == NULL)
-  {
-    m_dl.reset(cs->createDisplayList());
-
-    cs->beginFrame();
-    cs->setDisplayList(m_dl.get());
-    cs->applyVarAlfaStates();
-
-    m2::PointD coords[] =
-    {
-    /* 3*/  m2::PointD(0.0, -RulerHeight * k),
-    /* 4*/  m2::PointD(0.0,  0.0),
-    /*14*/  m2::PointD(CacheLength, -RulerHeight * k),
-    /*15*/  m2::PointD(CacheLength,  0.0 * k),
-    };
-
-    Brush::Info const brushInfo(f.m_color);
-    Resource const * brushRes = cs->fromID(cs->mapInfo(brushInfo));
-    m2::PointF const brushCenter = cs->pipeline(brushRes->m_pipelineID).texture()->mapPixel(brushRes->m_texRect.Center());
-
-    m2::PointF normal(0.0, 0.0);
-    cs->addTexturedStripStrided(coords , sizeof(m2::PointD),
-                               &normal, 0,
-                               &brushCenter, 0, ARRAY_SIZE(coords),
-                               m_depth, brushRes->m_pipelineID);
-
-    cs->setDisplayList(0);
-    cs->applyStates();
-    cs->endFrame();
-  }
-
-  // Create text DL.
-
-  ASSERT(!text.empty(), ());
-
-  {
-    m_textDL.reset();
-    m_textDL.reset(cs->createDisplayList());
-
-    cs->beginFrame();
-    cs->setDisplayList(m_textDL.get());
-    cs->applyVarAlfaStates();
-
-    strings::UniString uniString = strings::MakeUniString(text);
-    size_t length = uniString.size();
-    buffer_vector<Glyph::Info, 8> infos(length, Glyph::Info());
-    buffer_vector<Resource::Info const *, 8> resInfos(length, NULL);
-    buffer_vector<uint32_t, 8> ids(length, 0);
-    buffer_vector<Resource const *, 8> glyphRes(length, NULL);
-
-    for (size_t i = 0; i < uniString.size(); ++i)
-    {
-      infos[i] = Glyph::Info(GlyphKey(uniString[i], f.m_size, false, f.m_color),
-                                       controller->GetGlyphCache());
-
-      resInfos[i] = &infos[i];
-    }
-
-    if (cs->mapInfo(resInfos.data(), ids.data(), infos.size()))
-    {
-      for (size_t i = 0; i < ids.size(); ++i)
-      {
-        Resource const * res = cs->fromID(ids[i]);
-        glyphRes[i] = res;
-      }
-
-      int32_t pipelineID = glyphRes[0]->m_pipelineID;
-      shared_ptr<gl::BaseTexture> texture = cs->pipeline(pipelineID).texture();
-      double lengthFromStart = 0.0;
-
-      buffer_vector<m2::PointF, 48> coords;
-      buffer_vector<m2::PointF, 48> normals;
-      buffer_vector<m2::PointF, 48> texCoords;
-
-      for (size_t i = 0; i < uniString.size(); ++i)
-      {
-        double baseX = lengthFromStart;
-        coords.push_back(m2::PointD(baseX, 0.0));
-        coords.push_back(m2::PointD(baseX, 0.0));
-        coords.push_back(m2::PointD(baseX, 0.0));
-
-        coords.push_back(m2::PointD(baseX, 0.0));
-        coords.push_back(m2::PointD(baseX, 0.0));
-        coords.push_back(m2::PointD(baseX, 0.0));
-
-        m2::RectI resourceRect(glyphRes[i]->m_texRect);
-        resourceRect.Inflate(-1, -1);
-        double w = resourceRect.SizeX();
-        double h = resourceRect.SizeY();
-        lengthFromStart += infos[i].m_metrics.m_xAdvance;
-
-        normals.push_back(m2::PointF(0.0, 0.0));
-        normals.push_back(m2::PointF(0.0, -h));
-        normals.push_back(m2::PointF(w  , 0.0));
-
-        normals.push_back(m2::PointF(w  , 0.0));
-        normals.push_back(m2::PointF(0.0, -h));
-        normals.push_back(m2::PointF(w  , -h));
-
-        texCoords.push_back(texture->mapPixel(m2::PointF(resourceRect.minX(), resourceRect.maxY())));
-        texCoords.push_back(texture->mapPixel(m2::PointF(resourceRect.minX(), resourceRect.minY())));
-        texCoords.push_back(texture->mapPixel(m2::PointF(resourceRect.maxX(), resourceRect.maxY())));
-
-        texCoords.push_back(texture->mapPixel(m2::PointF(resourceRect.maxX(), resourceRect.maxY())));
-        texCoords.push_back(texture->mapPixel(m2::PointF(resourceRect.minX(), resourceRect.minY())));
-        texCoords.push_back(texture->mapPixel(m2::PointF(resourceRect.maxX(), resourceRect.minY())));
-      }
-
-      m_textLengthInPx = lengthFromStart;
-      cs->addTexturedListStrided(coords.data(), sizeof(m2::PointF),
-                                 normals.data(), sizeof(m2::PointF),
-                                 texCoords.data(), sizeof(m2::PointF),
-                                 coords.size(), m_depth, pipelineID);
-    }
-
-    cs->setDisplayList(0);
-    cs->endFrame();
-  }
-}
+  return false;
+}
+
+///@TODO UVR
+//void Ruler::RulerFrame::Cache(const string & text, FontDesc const & f)
+//{
+//  gui::Controller * controller = m_f.GetGuiController();
+//  Screen * cs = controller->GetCacheScreen();
+//  double const k = m_f.GetVisualScale();
+
+//  // Create solid line DL.
+//  if (m_dl == NULL)
+//  {
+//    m_dl.reset(cs->createDisplayList());
+
+//    cs->beginFrame();
+//    cs->setDisplayList(m_dl.get());
+//    cs->applyVarAlfaStates();
+
+//    m2::PointD coords[] =
+//    {
+//    /* 3*/  m2::PointD(0.0, -RulerHeight * k),
+//    /* 4*/  m2::PointD(0.0,  0.0),
+//    /*14*/  m2::PointD(CacheLength, -RulerHeight * k),
+//    /*15*/  m2::PointD(CacheLength,  0.0 * k),
+//    };
+
+//    Brush::Info const brushInfo(f.m_color);
+//    Resource const * brushRes = cs->fromID(cs->mapInfo(brushInfo));
+//    m2::PointF const brushCenter = cs->pipeline(brushRes->m_pipelineID).texture()->mapPixel(brushRes->m_texRect.Center());
+
+//    m2::PointF normal(0.0, 0.0);
+//    cs->addTexturedStripStrided(coords , sizeof(m2::PointD),
+//                               &normal, 0,
+//                               &brushCenter, 0, ARRAY_SIZE(coords),
+//                               m_depth, brushRes->m_pipelineID);
+
+//    cs->setDisplayList(0);
+//    cs->applyStates();
+//    cs->endFrame();
+//  }
+
+//  // Create text DL.
+
+//  ASSERT(!text.empty(), ());
+
+//  {
+//    m_textDL.reset();
+//    m_textDL.reset(cs->createDisplayList());
+
+//    cs->beginFrame();
+//    cs->setDisplayList(m_textDL.get());
+//    cs->applyVarAlfaStates();
+
+//    strings::UniString uniString = strings::MakeUniString(text);
+//    size_t length = uniString.size();
+//    buffer_vector<Glyph::Info, 8> infos(length, Glyph::Info());
+//    buffer_vector<Resource::Info const *, 8> resInfos(length, NULL);
+//    buffer_vector<uint32_t, 8> ids(length, 0);
+//    buffer_vector<Resource const *, 8> glyphRes(length, NULL);
+
+//    for (size_t i = 0; i < uniString.size(); ++i)
+//    {
+//      infos[i] = Glyph::Info(GlyphKey(uniString[i], f.m_size, false, f.m_color),
+//                                       controller->GetGlyphCache());
+
+//      resInfos[i] = &infos[i];
+//    }
+
+//    if (cs->mapInfo(resInfos.data(), ids.data(), infos.size()))
+//    {
+//      for (size_t i = 0; i < ids.size(); ++i)
+//      {
+//        Resource const * res = cs->fromID(ids[i]);
+//        glyphRes[i] = res;
+//      }
+
+//      int32_t pipelineID = glyphRes[0]->m_pipelineID;
+//      shared_ptr<gl::BaseTexture> texture = cs->pipeline(pipelineID).texture();
+//      double lengthFromStart = 0.0;
+
+//      buffer_vector<m2::PointF, 48> coords;
+//      buffer_vector<m2::PointF, 48> normals;
+//      buffer_vector<m2::PointF, 48> texCoords;
+
+//      for (size_t i = 0; i < uniString.size(); ++i)
+//      {
+//        double baseX = lengthFromStart;
+//        coords.push_back(m2::PointD(baseX, 0.0));
+//        coords.push_back(m2::PointD(baseX, 0.0));
+//        coords.push_back(m2::PointD(baseX, 0.0));
+
+//        coords.push_back(m2::PointD(baseX, 0.0));
+//        coords.push_back(m2::PointD(baseX, 0.0));
+//        coords.push_back(m2::PointD(baseX, 0.0));
+
+//        m2::RectI resourceRect(glyphRes[i]->m_texRect);
+//        resourceRect.Inflate(-1, -1);
+//        double w = resourceRect.SizeX();
+//        double h = resourceRect.SizeY();
+//        lengthFromStart += infos[i].m_metrics.m_xAdvance;
+
+//        normals.push_back(m2::PointF(0.0, 0.0));
+//        normals.push_back(m2::PointF(0.0, -h));
+//        normals.push_back(m2::PointF(w  , 0.0));
+
+//        normals.push_back(m2::PointF(w  , 0.0));
+//        normals.push_back(m2::PointF(0.0, -h));
+//        normals.push_back(m2::PointF(w  , -h));
+
+//        texCoords.push_back(texture->mapPixel(m2::PointF(resourceRect.minX(), resourceRect.maxY())));
+//        texCoords.push_back(texture->mapPixel(m2::PointF(resourceRect.minX(), resourceRect.minY())));
+//        texCoords.push_back(texture->mapPixel(m2::PointF(resourceRect.maxX(), resourceRect.maxY())));
+
+//        texCoords.push_back(texture->mapPixel(m2::PointF(resourceRect.maxX(), resourceRect.maxY())));
+//        texCoords.push_back(texture->mapPixel(m2::PointF(resourceRect.minX(), resourceRect.minY())));
+//        texCoords.push_back(texture->mapPixel(m2::PointF(resourceRect.maxX(), resourceRect.minY())));
+//      }
+
+//      m_textLengthInPx = lengthFromStart;
+//      cs->addTexturedListStrided(coords.data(), sizeof(m2::PointF),
+//                                 normals.data(), sizeof(m2::PointF),
+//                                 texCoords.data(), sizeof(m2::PointF),
+//                                 coords.size(), m_depth, pipelineID);
+//    }
+
+//    cs->setDisplayList(0);
+//    cs->endFrame();
+//  }
+//}
 
 void Ruler::RulerFrame::Purge()
 {
-  m_dl.reset();
-  m_textDL.reset();
 }
 
 bool Ruler::RulerFrame::IsHidingAnim() const
@@ -309,23 +297,24 @@ void Ruler::RulerFrame::HideAnimate(bool needPause)
   CreateAnim(1.0, 0.0, timeInterval, offset, false);
 }
 
-void Ruler::RulerFrame::Draw(OverlayRenderer * r, const math::Matrix<double, 3, 3> & m)
-{
-  ASSERT(m_dl, ());
-  ASSERT(m_textDL, ());
+///@TODO UVR
+//void Ruler::RulerFrame::Draw(OverlayRenderer * r, const math::Matrix<double, 3, 3> & m)
+//{
+//  ASSERT(m_dl, ());
+//  ASSERT(m_textDL, ());
 
-  UniformsHolder holder;
-  holder.insertValue(ETransparency, GetCurrentAlfa());
+//  UniformsHolder holder;
+//  holder.insertValue(ETransparency, GetCurrentAlfa());
 
-  r->drawDisplayList(m_dl.get(), math::Shift(
-                           math::Scale(m, m2::PointD(m_scale, 1.0)),
-                            m_orgPt), &holder);
+//  r->drawDisplayList(m_dl.get(), math::Shift(
+//                           math::Scale(m, m2::PointD(m_scale, 1.0)),
+//                            m_orgPt), &holder);
 
-  double const yOffset = -(2 + TextOffsetFromRuler * m_f.GetVisualScale());
-  r->drawDisplayList(m_textDL.get(),
-                     math::Shift(m, m_orgPt + m2::PointF(CacheLength * m_scale - m_textLengthInPx, yOffset)),
-                     &holder);
-}
+//  double const yOffset = -(2 + TextOffsetFromRuler * m_f.GetVisualScale());
+//  r->drawDisplayList(m_textDL.get(),
+//                     math::Shift(m, m_orgPt + m2::PointF(CacheLength * m_scale - m_textLengthInPx, yOffset)),
+//                     &holder);
+//}
 
 void Ruler::RulerFrame::CreateAnim(double startAlfa, double endAlfa, double timeInterval, double timeOffset, bool isVisibleAtEnd)
 {
@@ -421,38 +410,40 @@ Ruler::Params::Params()
 {}
 
 Ruler::Ruler(Params const & p)
-  : BaseT(p),
-    m_currentRangeIndex(InvalidUnitValue),
+  : m_currentRangeIndex(InvalidUnitValue),
     m_currSystem(0),
     m_framework(p.m_framework)
 {
-  setIsVisible(false);
+  ///@TODO UVR
+  //setIsVisible(false);
 }
 
 void Ruler::AnimateShow()
 {
-  RulerFrame * frame = GetMainFrame();
-  if (!isVisible() && (!frame->IsAnimActive() || frame->IsHidingAnim()))
-  {
-    setIsVisible(true);
-    frame->ShowAnimate(false);
-    m_framework->Invalidate();
-  }
-  else if (isVisible() && (frame->IsAnimActive() && frame->IsHidingAnim()))
-  {
-    frame->ShowAnimate(false);
-    m_framework->Invalidate();
-  }
+  ///@TODO UVR
+//  RulerFrame * frame = GetMainFrame();
+//  if (!isVisible() && (!frame->IsAnimActive() || frame->IsHidingAnim()))
+//  {
+//    setIsVisible(true);
+//    frame->ShowAnimate(false);
+//    m_framework->Invalidate();
+//  }
+//  else if (isVisible() && (frame->IsAnimActive() && frame->IsHidingAnim()))
+//  {
+//    frame->ShowAnimate(false);
+//    m_framework->Invalidate();
+//  }
 }
 
 void Ruler::AnimateHide()
 {
-  RulerFrame * frame = GetMainFrame();
-  if (isVisible() && (!frame->IsAnimActive() || !frame->IsHidingAnim()))
-  {
-    frame->HideAnimate(true);
-    m_framework->Invalidate();
-  }
+  ///@TODO UVR
+//  RulerFrame * frame = GetMainFrame();
+//  if (isVisible() && (!frame->IsAnimActive() || !frame->IsHidingAnim()))
+//  {
+//    frame->HideAnimate(true);
+//    m_framework->Invalidate();
+//  }
 }
 
 void Ruler::layout()
@@ -480,22 +471,24 @@ void Ruler::layout()
 
 void Ruler::UpdateText(const string & text)
 {
-  RulerFrame * frame = GetMainFrame();
-  if (frame->IsAnimActive() && frame->IsHidingAnim())
-    return;
+  ///@TODO UVR
+//  RulerFrame * frame = GetMainFrame();
+//  if (frame->IsAnimActive() && frame->IsHidingAnim())
+//    return;
 
-  if (frame->IsValid())
-    m_animFrame.reset(new RulerFrame(*frame, bind(&Ruler::AnimFrameAnimEnded, this, _1, _2)));
+//  if (frame->IsValid())
+//    m_animFrame.reset(new RulerFrame(*frame, bind(&Ruler::AnimFrameAnimEnded, this, _1, _2)));
 
-  frame->Cache(text, font(EActive));
-  if (isVisible())
-    frame->ShowAnimate(true);
+//  frame->Cache(text, font(EActive));
+//  if (isVisible())
+//    frame->ShowAnimate(true);
 }
 
 void Ruler::MainFrameAnimEnded(bool isVisible, RulerFrame * frame)
 {
-  setIsVisible(isVisible);
-  ASSERT(GetMainFrame() == frame, ());
+  ///@TODO UVR
+//  setIsVisible(isVisible);
+//  ASSERT(GetMainFrame() == frame, ());
 }
 
 void Ruler::AnimFrameAnimEnded(bool /*isVisible*/, RulerFrame * frame)
@@ -506,9 +499,11 @@ void Ruler::AnimFrameAnimEnded(bool /*isVisible*/, RulerFrame * frame)
 
 Ruler::RulerFrame * Ruler::GetMainFrame()
 {
-  if (!m_mainFrame)
-    m_mainFrame.reset(new RulerFrame(*m_framework, bind(&Ruler::MainFrameAnimEnded, this, _1, _2), depth()));
-  return m_mainFrame.get();
+  ///@TODO UVR
+//  if (!m_mainFrame)
+//    m_mainFrame.reset(new RulerFrame(*m_framework, bind(&Ruler::MainFrameAnimEnded, this, _1, _2), depth()));
+//  return m_mainFrame.get();
+  return nullptr;
 }
 
 Ruler::RulerFrame * Ruler::GetMainFrame() const
@@ -524,74 +519,78 @@ void Ruler::purge()
   m_mainFrame.reset();
   m_animFrame.reset();
 
-  setIsVisible(false);
+  ///@TODO UVR
+  //setIsVisible(false);
 }
 
 void Ruler::update()
 {
-  double const k = visualScale();
+  ///@TODO UVR
+//  double const k = visualScale();
 
-  ScreenBase const & screen = m_framework->GetNavigator().Screen();
+//  ScreenBase const & screen = m_framework->GetNavigator().Screen();
 
-  int const rulerHeight = my::rounds(RulerHeight * k);
-  int const minPxWidth = my::rounds(MinPixelWidth * k);
+//  int const rulerHeight = my::rounds(RulerHeight * k);
+//  int const minPxWidth = my::rounds(MinPixelWidth * k);
 
-  // pivot() here is the down right point of the ruler.
-  // Get global points of ruler and distance according to minPxWidth.
+//  // pivot() here is the down right point of the ruler.
+//  // Get global points of ruler and distance according to minPxWidth.
 
-  m2::PointD pt1 = screen.PtoG(pivot());
-  m2::PointD pt0 = screen.PtoG(pivot() - m2::PointD(minPxWidth, 0));
+//  m2::PointD pt1 = screen.PtoG(pivot());
+//  m2::PointD pt0 = screen.PtoG(pivot() - m2::PointD(minPxWidth, 0));
 
-  double const distanceInMetres = MercatorBounds::DistanceOnEarth(pt0, pt1);
+//  double const distanceInMetres = MercatorBounds::DistanceOnEarth(pt0, pt1);
 
-  // convert metres to units for calculating m_metresDiff
-  double metersDiff = CalcMetresDiff(distanceInMetres);
+//  // convert metres to units for calculating m_metresDiff
+//  double metersDiff = CalcMetresDiff(distanceInMetres);
 
-  bool const higherThanMax = metersDiff > MaxMetersWidth;
-  bool const lessThanMin = metersDiff < MinMetersWidth;
+//  bool const higherThanMax = metersDiff > MaxMetersWidth;
+//  bool const lessThanMin = metersDiff < MinMetersWidth;
 
-  // Calculate width of the ruler in pixels.
-  double scalerWidthInPx = minPxWidth;
+//  // Calculate width of the ruler in pixels.
+//  double scalerWidthInPx = minPxWidth;
 
-  if (higherThanMax)
-    scalerWidthInPx = minPxWidth * 3 / 2;
-  else if (!lessThanMin)
-  {
-    // Here we need to convert metres to pixels according to angle
-    // (in global coordinates) of the ruler.
+//  if (higherThanMax)
+//    scalerWidthInPx = minPxWidth * 3 / 2;
+//  else if (!lessThanMin)
+//  {
+//    // Here we need to convert metres to pixels according to angle
+//    // (in global coordinates) of the ruler.
 
-    double const a = ang::AngleTo(pt1, pt0);
-    pt0 = MercatorBounds::GetSmPoint(pt1, cos(a) * metersDiff, sin(a) * metersDiff);
+//    double const a = ang::AngleTo(pt1, pt0);
+//    pt0 = MercatorBounds::GetSmPoint(pt1, cos(a) * metersDiff, sin(a) * metersDiff);
 
-    scalerWidthInPx = my::rounds(pivot().Length(screen.GtoP(pt0)));
-  }
+//    scalerWidthInPx = my::rounds(pivot().Length(screen.GtoP(pt0)));
+//  }
 
-  m2::PointD orgPt = pivot() + m2::PointD(-scalerWidthInPx / 2, rulerHeight / 2);
+//  m2::PointD orgPt = pivot() + m2::PointD(-scalerWidthInPx / 2, rulerHeight / 2);
 
-  if (position() & EPosLeft)
-    orgPt.x -= scalerWidthInPx / 2;
+//  if (position() & EPosLeft)
+//    orgPt.x -= scalerWidthInPx / 2;
 
-  if (position() & EPosRight)
-    orgPt.x += scalerWidthInPx / 2;
+//  if (position() & EPosRight)
+//    orgPt.x += scalerWidthInPx / 2;
 
-  if (position() & EPosAbove)
-    orgPt.y -= rulerHeight / 2;
+//  if (position() & EPosAbove)
+//    orgPt.y -= rulerHeight / 2;
 
-  if (position() & EPosUnder)
-    orgPt.y += rulerHeight / 2;
+//  if (position() & EPosUnder)
+//    orgPt.y += rulerHeight / 2;
 
-  RulerFrame * frame = GetMainFrame();
-  frame->SetScale(scalerWidthInPx / CacheLength);
-  frame->SetOrgPoint(orgPt);
+//  RulerFrame * frame = GetMainFrame();
+//  frame->SetScale(scalerWidthInPx / CacheLength);
+//  frame->SetOrgPoint(orgPt);
 }
 
 m2::RectD Ruler::GetBoundRect() const
 {
-  FontDesc const & f = font(EActive);
-  RulerFrame * frame = GetMainFrame();
-  m2::PointD const org = frame->GetOrgPoint();
-  m2::PointD const size = m2::PointD(CacheLength * frame->GetScale(), f.m_size * 2);
-  return m2::RectD(org - m2::PointD(size.x, 0.0), org + m2::PointD(0.0, size.y));
+  ///@TODO UVR
+//  FontDesc const & f = font(EActive);
+//  RulerFrame * frame = GetMainFrame();
+//  m2::PointD const org = frame->GetOrgPoint();
+//  m2::PointD const size = m2::PointD(CacheLength * frame->GetScale(), f.m_size * 2);
+//  return m2::RectD(org - m2::PointD(size.x, 0.0), org + m2::PointD(0.0, size.y));
+  return m2::RectD();
 }
 
 void Ruler::cache()
@@ -600,18 +599,19 @@ void Ruler::cache()
   update();
 }
 
-void Ruler::draw(OverlayRenderer * s, math::Matrix<double, 3, 3> const & m) const
-{
-  if (isVisible())
-  {
-    checkDirtyLayout();
+///@TODO UVR
+//void Ruler::draw(OverlayRenderer * s, math::Matrix<double, 3, 3> const & m) const
+//{
+//  if (isVisible())
+//  {
+//    checkDirtyLayout();
 
-    RulerFrame * frame = GetMainFrame();
-    frame->Draw(s, m);
-    if (m_animFrame)
-      m_animFrame->Draw(s, m);
-  }
-}
+//    RulerFrame * frame = GetMainFrame();
+//    frame->Draw(s, m);
+//    if (m_animFrame)
+//      m_animFrame->Draw(s, m);
+//  }
+//}
 
 int Ruler::GetTextOffsetFromLine() const
 {
diff --git a/map/ruler.hpp b/map/ruler.hpp
index 41e9fdc7fc..8881e0a0f9 100644
--- a/map/ruler.hpp
+++ b/map/ruler.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
-#include "gui/element.hpp"
+#include "geometry/point2d.hpp"
+#include "geometry/rect2d.hpp"
 
 #include "std/shared_ptr.hpp"
 #include "std/unique_ptr.hpp"
@@ -12,23 +13,11 @@ namespace anim
   class Task;
 }
 
-namespace graphics
-{
-  class DisplayList;
-
-  namespace gl
-  {
-    class OverlayRenderer;
-  }
-}
-
 class Framework;
 
 
-class Ruler : public gui::Element
+class Ruler
 {
-  typedef gui::Element BaseT;
-
   class RulerFrame
   {
   public:
@@ -43,7 +32,6 @@ class Ruler : public gui::Element
 
     bool IsValid() const;
 
-    void Cache(const string & text, const graphics::FontDesc & f);
     void Purge();
     bool IsHidingAnim() const;
     bool IsAnimActive() const;
@@ -54,7 +42,6 @@ class Ruler : public gui::Element
 
     void ShowAnimate(bool needPause);
     void HideAnimate(bool needPause);
-    void Draw(graphics::OverlayRenderer * r, math::Matrix<double, 3, 3> const & m);
 
   private:
     void CreateAnim(double startAlfa, double endAlfa,
@@ -66,9 +53,6 @@ class Ruler : public gui::Element
   private:
     Framework & m_f;
 
-    shared_ptr<graphics::DisplayList> m_dl;
-    shared_ptr<graphics::DisplayList> m_textDL;
-
     int m_textLengthInPx;
     double m_scale;
     double m_depth;
@@ -97,7 +81,7 @@ private:
 
 public:
 
-  struct Params : public Element::Params
+  struct Params
   {
     Framework * m_framework;
     Params();
@@ -112,8 +96,6 @@ public:
   //@{
   virtual m2::RectD GetBoundRect() const;
 
-  void draw(graphics::OverlayRenderer * r, math::Matrix<double, 3, 3> const & m) const;
-
   void update();
   void layout();
   void cache();
diff --git a/map/track.cpp b/map/track.cpp
index 6eadcdbac6..b2ded1d4a2 100644
--- a/map/track.cpp
+++ b/map/track.cpp
@@ -2,11 +2,8 @@
 
 #include "indexer/mercator.hpp"
 
-#include "graphics/screen.hpp"
-#include "graphics/pen.hpp"
-#include "graphics/depth_constants.hpp"
-#include "graphics/display_list.hpp"
-#include "graphics/defines.hpp"
+#include "drape/color.hpp"
+#include "drape/drape_global.hpp"
 
 #include "geometry/distance.hpp"
 #include "geometry/simplification.hpp"
@@ -20,7 +17,8 @@
 
 Track::~Track()
 {
-  DeleteDisplayList();
+  ///@TODO UVR
+  //DeleteDisplayList();
 }
 
 Track * Track::CreatePersistent()
@@ -36,17 +34,21 @@ float Track::GetMainWidth() const
   return m_outlines.back().m_lineWidth;
 }
 
-const graphics::Color & Track::GetMainColor() const
+dp::Color const & Track::GetMainColor() const
 {
   ASSERT(!m_outlines.empty(), ());
   return m_outlines.back().m_color;
 }
 
-void Track::DeleteDisplayList() const
-{
-  delete m_dList;
-  m_dList = nullptr;
-}
+///@TODO UVR
+//void Track::DeleteDisplayList() const
+//{
+//  if (m_dList)
+//  {
+//    delete m_dList;
+//    m_dList = nullptr;
+//  }
+//}
 
 void Track::AddOutline(TrackOutline const * outline, size_t arraySize)
 {
@@ -58,10 +60,11 @@ void Track::AddOutline(TrackOutline const * outline, size_t arraySize)
   });
 }
 
-void Track::Draw(graphics::Screen * pScreen, MatrixT const & matrix) const
-{
-  pScreen->drawDisplayList(m_dList, matrix);
-}
+///@TODO UVR
+//void Track::Draw(graphics::Screen * pScreen, MatrixT const & matrix) const
+//{
+//  pScreen->drawDisplayList(m_dList, matrix);
+//}
 
 void Track::CreateDisplayListPolyline(graphics::Screen * dlScreen, PointContainerT const & pts) const
 {
@@ -75,25 +78,26 @@ void Track::CreateDisplayListPolyline(graphics::Screen * dlScreen, PointContaine
   }
 }
 
+///@TODO UVR
 void Track::CreateDisplayList(graphics::Screen * dlScreen, MatrixT const & matrix, bool isScaleChanged,
                               int, double, location::RouteMatchingInfo const &) const
 {
   if (HasDisplayLists() && !isScaleChanged)
     return;
 
-  DeleteDisplayList();
+//  DeleteDisplayList();
 
-  m_dList = dlScreen->createDisplayList();
-  dlScreen->beginFrame();
-  dlScreen->setDisplayList(m_dList);
+//  m_dList = dlScreen->createDisplayList();
+//  dlScreen->beginFrame();
+//  dlScreen->setDisplayList(m_dList);
 
-  PointContainerT pts;
-  pts.reserve(m_polyline.GetSize());
-  TransformAndSymplifyPolyline(m_polyline, matrix, GetMainWidth(), pts);
-  CreateDisplayListPolyline(dlScreen, pts);
+//  PointContainerT pts;
+//  pts.reserve(m_polyline.GetSize());
+//  TransformAndSymplifyPolyline(m_polyline, matrix, GetMainWidth(), pts);
+//  CreateDisplayListPolyline(dlScreen, pts);
 
-  dlScreen->setDisplayList(0);
-  dlScreen->endFrame();
+//  dlScreen->setDisplayList(0);
+//  dlScreen->endFrame();
 }
 
 double Track::GetLengthMeters() const
@@ -117,13 +121,14 @@ double Track::GetLengthMeters() const
 
 void Track::Swap(Track & rhs)
 {
-  swap(m_rect, rhs.m_rect);
-  swap(m_outlines, rhs.m_outlines);
-  m_name.swap(rhs.m_name);
-  m_polyline.Swap(rhs.m_polyline);
-
-  DeleteDisplayList();
-  rhs.DeleteDisplayList();
+  ///@TODO UVR
+  //swap(m_rect, rhs.m_rect);
+  //swap(m_outlines, rhs.m_outlines);
+  //m_name.swap(rhs.m_name);
+  //m_polyline.Swap(rhs.m_polyline);
+
+  //DeleteDisplayList();
+  //rhs.DeleteDisplayList();
 }
 
 void Track::CleanUp() const
@@ -149,5 +154,3 @@ void TransformAndSymplifyPolyline(Track::PolylineD const & polyline, MatrixT con
   SimplifyDP(pts1.begin(), pts1.end(), width,
              m2::DistanceToLineSquare<m2::PointD>(), MakeBackInsertFunctor(pts));
 }
-
-
diff --git a/map/track.hpp b/map/track.hpp
index a13dcb9c93..e9429af82d 100644
--- a/map/track.hpp
+++ b/map/track.hpp
@@ -1,22 +1,17 @@
 #pragma once
 
+#include "drape/drape_global.hpp"
+#include "drape/color.hpp"
+
 #include "geometry/polyline2d.hpp"
 #include "geometry/screenbase.hpp"
 
-#include "graphics/color.hpp"
-#include "graphics/defines.hpp"
-
 #include "std/noncopyable.hpp"
 
 #include "base/buffer_vector.hpp"
 
 
 class Navigator;
-namespace graphics
-{
-  class Screen;
-  class DisplayList;
-}
 namespace location
 {
   class RouteMatchingInfo;
@@ -52,13 +47,15 @@ public:
   /// @note Move semantics is used here.
   virtual Track * CreatePersistent();
   float GetMainWidth() const;
-  graphics::Color const & GetMainColor() const;
+  dp::Color const & GetMainColor() const;
+
 
-  virtual void Draw(graphics::Screen * pScreen, MatrixT const & matrix) const;
-  virtual void CreateDisplayList(graphics::Screen * dlScreen, MatrixT const & matrix, bool isScaleChanged,
+  /// @TODO UVR
+  //virtual void Draw(graphics::Screen * pScreen, MatrixT const & matrix) const;
+  //virtual void CreateDisplayList(graphics::Screen * dlScreen, MatrixT const & matrix, bool isScaleChanged,
                          int, double, location::RouteMatchingInfo const &) const;
-  virtual void CleanUp() const;
-  virtual bool HasDisplayLists() const;
+  //virtual void CleanUp() const;
+  //virtual bool HasDisplayLists() const;
 
   /// @name Simple Getters-Setter
   //@{
@@ -66,7 +63,7 @@ public:
   struct TrackOutline
   {
     float m_lineWidth;
-    graphics::Color m_color;
+    dp::Color m_color;
   };
 
   void AddOutline(TrackOutline const * outline, size_t arraySize);
@@ -93,7 +90,8 @@ private:
   PolylineD m_polyline;
   m2::RectD m_rect;
 
-  mutable graphics::DisplayList * m_dList = nullptr;
+  ///@TODO UVR
+  //mutable graphics::DisplayList * m_dList = nullptr;
 };
 
 void TransformPolyline(Track::PolylineD const & polyline, MatrixT const & matrix, PointContainerT & pts);
diff --git a/map/user_mark.hpp b/map/user_mark.hpp
index 73420bc00d..7ec98cc8f1 100644
--- a/map/user_mark.hpp
+++ b/map/user_mark.hpp
@@ -14,12 +14,6 @@
 class UserMarkContainer;
 class PaintOverlayEvent;
 class UserMarkDLCache;
-
-namespace graphics
-{
-  class DisplayList;
-}
-
 class UserMarkCopy;
 
 class UserMark
@@ -197,7 +191,7 @@ class ICustomDrawable : public UserMark
 public:
   ICustomDrawable(m2::PointD const & ptOrg, UserMarkContainer * container) : UserMark(ptOrg, container) {}
   bool IsCustomDrawable() const { return true; }
-  virtual graphics::DisplayList * GetDisplayList(UserMarkDLCache * cache) const = 0;
+  //virtual graphics::DisplayList * GetDisplayList(UserMarkDLCache * cache) const = 0;
   virtual double GetAnimScaleFactor() const = 0;
   virtual m2::PointD const & GetPixelOffset() const = 0;
 };
diff --git a/map/user_mark_container.cpp b/map/user_mark_container.cpp
index fac33745d5..5b362d4f37 100644
--- a/map/user_mark_container.cpp
+++ b/map/user_mark_container.cpp
@@ -1,12 +1,7 @@
-#include "user_mark_container.hpp"
-#include "framework.hpp"
-#include "anim_phase_chain.hpp"
+#include "map/user_mark_container.hpp"
 
-#include "render/drawer.hpp"
-
-#include "graphics/display_list.hpp"
-#include "graphics/screen.hpp"
-#include "graphics/depth_constants.hpp"
+#include "map/framework.hpp"
+#include "map/anim_phase_chain.hpp"
 
 #include "geometry/transformations.hpp"
 
@@ -72,50 +67,51 @@ namespace
     m2::PointD m_globalCenter;
   };
 
-  void DrawUserMarkByPoint(double scale,
-                           double visualScale,
-                           m2::PointD const & pixelOfsset,
-                           PaintOverlayEvent const & event,
-                           graphics::DisplayList * dl,
-                           m2::PointD const & ptOrg)
-  {
-#ifndef USE_DRAPE
-    ScreenBase const & modelView = event.GetModelView();
-    graphics::Screen * screen = GPUDrawer::GetScreen(event.GetDrawer());
-    m2::PointD pxPoint = modelView.GtoP(ptOrg);
-    pxPoint += (pixelOfsset * visualScale);
-    math::Matrix<double, 3, 3> m = math::Shift(math::Scale(math::Identity<double, 3>(),
-                                                           scale, scale),
-                                               pxPoint.x, pxPoint.y);
-    dl->draw(screen, m);
-#endif // USE_DRAPE
-  }
-
-  void DrawUserMarkImpl(double scale,
-                        double visualScale,
-                        m2::PointD const & pixelOfsset,
-                        PaintOverlayEvent const & event,
-                        graphics::DisplayList * dl,
-                        UserMark const * mark)
-  {
-    DrawUserMarkByPoint(scale, visualScale, pixelOfsset, event, dl, mark->GetOrg());
-  }
-
-  void DrawUserMark(double scale,
-                    double visualScale,
-                    PaintOverlayEvent const & event,
-                    UserMarkDLCache * cache,
-                    UserMarkDLCache::Key const & defaultKey,
-                    UserMark const * mark)
-  {
-    if (mark->IsCustomDrawable())
-    {
-      ICustomDrawable const * drawable = static_cast<ICustomDrawable const *>(mark);
-      DrawUserMarkImpl(drawable->GetAnimScaleFactor(), visualScale, drawable->GetPixelOffset(), event, drawable->GetDisplayList(cache), mark);
-    }
-    else
-      DrawUserMarkImpl(scale, visualScale, m2::PointD(0.0, 0.0), event, cache->FindUserMark(defaultKey), mark);
-  }
+  ///@TODO UVR
+//  void DrawUserMarkByPoint(double scale,
+//                           double visualScale,
+//                           m2::PointD const & pixelOfsset,
+//                           PaintOverlayEvent const & event,
+//                           graphics::DisplayList * dl,
+//                           m2::PointD const & ptOrg)
+//  {
+//#ifndef USE_DRAPE
+//    ScreenBase const & modelView = event.GetModelView();
+//    graphics::Screen * screen = event.GetDrawer()->screen();
+//    m2::PointD pxPoint = modelView.GtoP(ptOrg);
+//    pxPoint += (pixelOfsset * visualScale);
+//    math::Matrix<double, 3, 3> m = math::Shift(math::Scale(math::Identity<double, 3>(),
+//                                                           scale, scale),
+//                                               pxPoint.x, pxPoint.y);
+//    dl->draw(screen, m);
+//#endif // USE_DRAPE
+//  }
+
+//  void DrawUserMarkImpl(double scale,
+//                        double visualScale,
+//                        m2::PointD const & pixelOfsset,
+//                        PaintOverlayEvent const & event,
+//                        graphics::DisplayList * dl,
+//                        UserMark const * mark)
+//  {
+//    DrawUserMarkByPoint(scale, visualScale, pixelOfsset, event, dl, mark->GetOrg());
+//  }
+
+//  void DrawUserMark(double scale,
+//                    double visualScale,
+//                    PaintOverlayEvent const & event,
+//                    UserMarkDLCache * cache,
+//                    UserMarkDLCache::Key const & defaultKey,
+//                    UserMark const * mark)
+//  {
+//    if (mark->IsCustomDrawable())
+//    {
+//      ICustomDrawable const * drawable = static_cast<ICustomDrawable const *>(mark);
+//      DrawUserMarkImpl(drawable->GetAnimScaleFactor(), visualScale, drawable->GetPixelOffset(), event, drawable->GetDisplayList(cache), mark);
+//    }
+//    else
+//      DrawUserMarkImpl(scale, visualScale, m2::PointD(0.0, 0.0), event, cache->FindUserMark(defaultKey), mark);
+//  }
 }
 
 UserMarkContainer::UserMarkContainer(double layerDepth, Framework & fm)
@@ -153,14 +149,15 @@ UserMark const * UserMarkContainer::FindMarkInRect(m2::AnyRectD const & rect, do
 
 void UserMarkContainer::Draw(PaintOverlayEvent const & e, UserMarkDLCache * cache) const
 {
-#ifndef USE_DRAPE
-  if (IsVisible() && IsDrawable())
-  {
-    UserMarkDLCache::Key defaultKey(GetTypeName(), graphics::EPosCenter, m_layerDepth);
-    ForEachInRect(e.GetClipRect(), bind(&DrawUserMark, 1.0, m_framework.GetVisualScale(),
-                                        e, cache, defaultKey, _1));
-  }
-#endif // USE_DRAPE
+  ///@TODO UVR
+//#ifndef USE_DRAPE
+//  if (IsVisible() && IsDrawable())
+//  {
+//    UserMarkDLCache::Key defaultKey(GetTypeName(), graphics::EPosCenter, m_layerDepth);
+//    ForEachInRect(e.GetClipRect(), bind(&DrawUserMark, 1.0, m_framework.GetVisualScale(),
+//                                        e, cache, defaultKey, _1));
+//  }
+//#endif // USE_DRAPE
 }
 
 void UserMarkContainer::Clear(size_t skipCount/* = 0*/)
@@ -318,18 +315,19 @@ void SelectionContainer::ActivateMark(UserMark const * userMark, bool needAnim)
 
 void SelectionContainer::Draw(const PaintOverlayEvent & e, UserMarkDLCache * cache) const
 {
-  if (m_container != NULL)
-  {
-    UserMarkDLCache::Key defaultKey(m_container->GetActiveTypeName(),
-                                    graphics::EPosCenter,
-                                    graphics::activePinDepth);
-
-    DrawUserMarkByPoint(GetActiveMarkScale(),
-                        m_fm.GetVisualScale(),
-                        m2::PointD(0, 0),
-                        e, cache->FindUserMark(defaultKey),
-                        m_ptOrg);
-  }
+  ///@TODO UVR
+//  if (m_container != NULL)
+//  {
+//    UserMarkDLCache::Key defaultKey(m_container->GetActiveTypeName(),
+//                                    graphics::EPosCenter,
+//                                    graphics::activePinDepth);
+
+//    DrawUserMarkByPoint(GetActiveMarkScale(),
+//                        m_fm.GetVisualScale(),
+//                        m2::PointD(0, 0),
+//                        e, cache->FindUserMark(defaultKey),
+//                        m_ptOrg);
+//  }
 }
 
 bool SelectionContainer::IsActive() const
@@ -341,7 +339,8 @@ void SelectionContainer::StartActivationAnim()
 {
   m_animTask.reset(new PinAnimation(m_fm));
   m_fm.GetAnimController()->AddTask(m_animTask);
-  m_fm.Invalidate();
+  ///@TODO UVR
+  //m_fm.Invalidate();
 }
 
 void SelectionContainer::KillActivationAnim()
diff --git a/map/user_mark_container.hpp b/map/user_mark_container.hpp
index 79b11aff09..92f5d878d7 100644
--- a/map/user_mark_container.hpp
+++ b/map/user_mark_container.hpp
@@ -19,12 +19,6 @@ namespace anim
   class Task;
 }
 
-namespace graphics
-{
-  class DisplayList;
-  class Screen;
-}
-
 class UserMarkContainer : private noncopyable
 {
 public:
@@ -62,7 +56,7 @@ public:
   UserMarkContainer(double layerDepth, Framework & fm);
   virtual ~UserMarkContainer();
 
-  void SetScreen(graphics::Screen * cacheScreen);
+  //void SetScreen(graphics::Screen * cacheScreen);
   virtual Type GetType() const = 0;
 
   bool IsVisible() const { return m_isVisible; }
diff --git a/map/user_mark_dl_cache.cpp b/map/user_mark_dl_cache.cpp
index c58f443f25..51f33e97f0 100644
--- a/map/user_mark_dl_cache.cpp
+++ b/map/user_mark_dl_cache.cpp
@@ -2,101 +2,87 @@
 
 #include "base/stl_add.hpp"
 
-#include "graphics/display_list.hpp"
-#include "graphics/screen.hpp"
-
-namespace
-{
-  struct Deleter
-  {
-    void operator()(pair<UserMarkDLCache::Key, graphics::DisplayList *> const & node)
-    {
-      delete node.second;
-    }
-  };
-}
-
-UserMarkDLCache::UserMarkDLCache(graphics::Screen * cacheScreen)
-  : m_cacheScreen(cacheScreen)
+UserMarkDLCache::UserMarkDLCache()
 {
 }
 
 UserMarkDLCache::~UserMarkDLCache()
 {
-  DeleteRange(m_dls, Deleter());
-  m_cacheScreen = NULL;
 }
 
-graphics::DisplayList * UserMarkDLCache::FindUserMark(UserMarkDLCache::Key const & key)
-{
-  node_t node = m_dls.find(key);
-  if (node != m_dls.end())
-    return node->second;
+///@TODO UVR
+//graphics::DisplayList * UserMarkDLCache::FindUserMark(UserMarkDLCache::Key const & key)
+//{
+//  node_t node = m_dls.find(key);
+//  if (node != m_dls.end())
+//    return node->second;
 
-  return CreateDL(key);
-}
+//  return CreateDL(key);
+//}
 
 namespace
 {
-  m2::RectD CalcCoords(double const & halfSizeX, double const & halfSizeY, graphics::EPosition anchor)
-  {
-    m2::RectD result(-halfSizeX, -halfSizeY, halfSizeX, halfSizeY);
-
-    if (anchor & graphics::EPosAbove)
-      result.Offset(0.0, -halfSizeY);
-    else if (anchor & graphics::EPosUnder)
-      result.Offset(0.0, halfSizeY);
-
-    if (anchor & graphics::EPosLeft)
-      result.Offset(halfSizeX, 0.0);
-    else if (anchor & graphics::EPosRight)
-      result.Offset(-halfSizeX, 0.0);
-
-    return result;
-  }
+///@TODO UVR
+//  m2::RectD CalcCoords(double const & halfSizeX, double const & halfSizeY, graphics::EPosition anchor)
+//  {
+//    m2::RectD result(-halfSizeX, -halfSizeY, halfSizeX, halfSizeY);
+
+//    if (anchor & graphics::EPosAbove)
+//      result.Offset(0.0, -halfSizeY);
+//    else if (anchor & graphics::EPosUnder)
+//      result.Offset(0.0, halfSizeY);
+
+//    if (anchor & graphics::EPosLeft)
+//      result.Offset(halfSizeX, 0.0);
+//    else if (anchor & graphics::EPosRight)
+//      result.Offset(-halfSizeX, 0.0);
+
+//    return result;
+//  }
 }
 
-graphics::DisplayList * UserMarkDLCache::CreateDL(UserMarkDLCache::Key const & key)
-{
-  using namespace graphics;
-
-  graphics::DisplayList * dl = m_cacheScreen->createDisplayList();
-  m_cacheScreen->beginFrame();
-  m_cacheScreen->setDisplayList(dl);
-
-  Icon::Info infoKey(key.m_name);
-  Resource const * res = m_cacheScreen->fromID(m_cacheScreen->findInfo(infoKey));
-  shared_ptr<gl::BaseTexture> texture = m_cacheScreen->pipeline(res->m_pipelineID).texture();
-
-  m2::RectU texRect = res->m_texRect;
-  m2::RectD coord = CalcCoords(texRect.SizeX() / 2.0, texRect.SizeY() / 2.0, key.m_anchor);
-
-  m2::PointD coords[] =
-  {
-    coord.LeftBottom(),
-    coord.LeftTop(),
-    coord.RightBottom(),
-    coord.RightTop()
-  };
-  m2::PointF normal(0.0, 0.0);
-
-  m2::PointF texCoords[] =
-  {
-    texture->mapPixel(m2::PointF(texRect.minX(), texRect.minY())),
-    texture->mapPixel(m2::PointF(texRect.minX(), texRect.maxY())),
-    texture->mapPixel(m2::PointF(texRect.maxX(), texRect.minY())),
-    texture->mapPixel(m2::PointF(texRect.maxX(), texRect.maxY()))
-  };
-
-  m_cacheScreen->addTexturedStripStrided(coords, sizeof(m2::PointD),
-                                       &normal, 0,
-                                       texCoords, sizeof(m2::PointF),
-                                       4, key.m_depthLayer, res->m_pipelineID);
-
-  m_cacheScreen->setDisplayList(NULL);
-  m_cacheScreen->endFrame();
-
-  m_dls.insert(make_pair(key, dl));
-
-  return dl;
-}
+///@TODO UVR
+//graphics::DisplayList * UserMarkDLCache::CreateDL(UserMarkDLCache::Key const & key)
+//{
+//  using namespace graphics;
+
+//  graphics::DisplayList * dl = m_cacheScreen->createDisplayList();
+//  m_cacheScreen->beginFrame();
+//  m_cacheScreen->setDisplayList(dl);
+
+//  Icon::Info infoKey(key.m_name);
+//  Resource const * res = m_cacheScreen->fromID(m_cacheScreen->findInfo(infoKey));
+//  shared_ptr<gl::BaseTexture> texture = m_cacheScreen->pipeline(res->m_pipelineID).texture();
+
+//  m2::RectU texRect = res->m_texRect;
+//  m2::RectD coord = CalcCoords(texRect.SizeX() / 2.0, texRect.SizeY() / 2.0, key.m_anchor);
+
+//  m2::PointD coords[] =
+//  {
+//    coord.LeftBottom(),
+//    coord.LeftTop(),
+//    coord.RightBottom(),
+//    coord.RightTop()
+//  };
+//  m2::PointF normal(0.0, 0.0);
+
+//  m2::PointF texCoords[] =
+//  {
+//    texture->mapPixel(m2::PointF(texRect.minX(), texRect.minY())),
+//    texture->mapPixel(m2::PointF(texRect.minX(), texRect.maxY())),
+//    texture->mapPixel(m2::PointF(texRect.maxX(), texRect.minY())),
+//    texture->mapPixel(m2::PointF(texRect.maxX(), texRect.maxY()))
+//  };
+
+//  m_cacheScreen->addTexturedStripStrided(coords, sizeof(m2::PointD),
+//                                       &normal, 0,
+//                                       texCoords, sizeof(m2::PointF),
+//                                       4, key.m_depthLayer, res->m_pipelineID);
+
+//  m_cacheScreen->setDisplayList(NULL);
+//  m_cacheScreen->endFrame();
+
+//  m_dls.insert(make_pair(key, dl));
+
+//  return dl;
+//}
diff --git a/map/user_mark_dl_cache.hpp b/map/user_mark_dl_cache.hpp
index 8994f8c907..ffa7e1ba21 100644
--- a/map/user_mark_dl_cache.hpp
+++ b/map/user_mark_dl_cache.hpp
@@ -1,26 +1,21 @@
 #pragma once
 
+#include "drape/drape_global.hpp"
+
 #include "base/math.hpp"
-#include "graphics/defines.hpp"
 
 #include "std/map.hpp"
 
-namespace graphics
-{
-  class Screen;
-  class DisplayList;
-}
-
 class UserMarkDLCache
 {
 public:
   struct Key
   {
-    Key(string const & name, graphics::EPosition anchor, double depthLayer)
+    Key(string const & name, dp::Anchor anchor, double depthLayer)
       : m_name(name), m_anchor(anchor), m_depthLayer(depthLayer) {}
 
     string m_name;
-    graphics::EPosition m_anchor;
+    dp::Anchor m_anchor;
     double m_depthLayer;
 
     bool operator < (Key const & other) const
@@ -34,17 +29,15 @@ public:
     }
   };
 
-  UserMarkDLCache(graphics::Screen * cacheScreen);
+  UserMarkDLCache();
   ~UserMarkDLCache();
 
-  graphics::DisplayList * FindUserMark(Key const & key);
+  ///@TODO UVR
+  //graphics::DisplayList * FindUserMark(Key const & key);
 
 private:
-  graphics::DisplayList * CreateDL(Key const & key);
+  //graphics::DisplayList * CreateDL(Key const & key);
 
 private:
-  graphics::Screen * m_cacheScreen;
-  typedef map<Key, graphics::DisplayList *> cache_t;
-  typedef cache_t::iterator node_t;
-  cache_t m_dls;
+  //graphics::Screen * m_cacheScreen;
 };