diff --git a/escher/Makefile b/escher/Makefile
index 12224b3d3..57a76c332 100644
--- a/escher/Makefile
+++ b/escher/Makefile
@@ -12,6 +12,7 @@ objs += $(addprefix escher/src/,\
   responder.o\
   scroll_view.o\
   scroll_view_indicator.o\
+  simple_table_view.o\
   solid_color_view.o\
   stack_view.o\
   stack_view_controller.o\
@@ -20,7 +21,6 @@ objs += $(addprefix escher/src/,\
   tab_view.o\
   tab_view_cell.o\
   tab_view_controller.o\
-  table_view.o\
   table_view_cell.o\
   text_field.o\
   text_view.o\
diff --git a/escher/include/escher.h b/escher/include/escher.h
index 42ea1465d..0d19e8a96 100644
--- a/escher/include/escher.h
+++ b/escher/include/escher.h
@@ -12,6 +12,7 @@
 #include <escher/responder.h>
 #include <escher/scroll_view.h>
 #include <escher/scroll_view_indicator.h>
+#include <escher/simple_table_view.h>
 #include <escher/solid_color_view.h>
 #include <escher/stack_view_controller.h>
 #include <escher/switch_view.h>
@@ -19,7 +20,6 @@
 #include <escher/text_field.h>
 #include <escher/text_view.h>
 #include <escher/tab_view_controller.h>
-#include <escher/table_view.h>
 #include <escher/table_view_cell.h>
 #include <escher/tiled_view.h>
 #include <escher/view.h>
diff --git a/escher/include/escher/list_view.h b/escher/include/escher/list_view.h
index f908d5514..beba4b84f 100644
--- a/escher/include/escher/list_view.h
+++ b/escher/include/escher/list_view.h
@@ -1,9 +1,9 @@
 #ifndef ESCHER_LIST_VIEW_H
 #define ESCHER_LIST_VIEW_H
 
-#include <escher/table_view.h>
+#include <escher/simple_table_view.h>
 
-class ListViewDataSource : public TableViewDataSource{
+class ListViewDataSource : public SimpleTableViewDataSource{
 public:
   int numberOfColumns() override;
   KDCoordinate cellWidth() override;
@@ -11,7 +11,7 @@ public:
   virtual void willDisplayCellForIndex(View * cell, int index);
 };
 
-class ListView : public TableView {
+class ListView : public SimpleTableView {
 public:
   ListView(ListViewDataSource * dataSource, KDCoordinate topMargin = 0, KDCoordinate rightMargin = 0,
     KDCoordinate bottomMargin = 0, KDCoordinate leftMargin = 0);
diff --git a/escher/include/escher/table_view.h b/escher/include/escher/simple_table_view.h
similarity index 80%
rename from escher/include/escher/table_view.h
rename to escher/include/escher/simple_table_view.h
index beaae14c2..aac7bf2a2 100644
--- a/escher/include/escher/table_view.h
+++ b/escher/include/escher/simple_table_view.h
@@ -1,9 +1,9 @@
-#ifndef ESCHER_TABLE_VIEW_H
-#define ESCHER_TABLE_VIEW_H
+#ifndef ESCHER_SIMPLE_TABLE_VIEW_H
+#define ESCHER_SIMPLE_TABLE_VIEW_H
 
 #include <escher/scroll_view.h>
 
-class TableViewDataSource {
+class SimpleTableViewDataSource {
 public:
   virtual int numberOfRows() = 0;
   virtual int numberOfColumns() = 0;
@@ -14,9 +14,9 @@ public:
   virtual int reusableCellCount() = 0;
 };
 
-class TableView : public ScrollView {
+class SimpleTableView : public ScrollView {
 public:
-  TableView(TableViewDataSource * dataSource, KDCoordinate topMargin = 0, KDCoordinate rightMargin = 0,
+  SimpleTableView(SimpleTableViewDataSource * dataSource, KDCoordinate topMargin = 0, KDCoordinate rightMargin = 0,
     KDCoordinate bottomMargin = 0, KDCoordinate leftMargin = 0);
 
   void scrollToCell(int x, int y);
@@ -28,7 +28,7 @@ protected:
 private:
   class ContentView : public View {
   public:
-    ContentView(TableView * tableView, TableViewDataSource * dataSource);
+    ContentView(SimpleTableView * tableView, SimpleTableViewDataSource * dataSource);
 
     KDCoordinate height() const;
     KDCoordinate width() const;
@@ -56,8 +56,8 @@ private:
     bool columnAtIndexIsBeforeFullyVisibleRange(int index) const;
     bool rowAtIndexIsAfterFullyVisibleRange(int index) const;
     bool columnAtIndexIsAfterFullyVisibleRange(int index) const;
-    TableView * m_tableView;
-    TableViewDataSource * m_dataSource;
+    SimpleTableView * m_tableView;
+    SimpleTableViewDataSource * m_dataSource;
   };
 
   void layoutSubviews() override;
diff --git a/escher/src/list_view.cpp b/escher/src/list_view.cpp
index fa143d947..0080e3c4d 100644
--- a/escher/src/list_view.cpp
+++ b/escher/src/list_view.cpp
@@ -24,7 +24,7 @@ void ListViewDataSource::willDisplayCellForIndex(View * cell, int index) {
 
 ListView::ListView(ListViewDataSource * dataSource, KDCoordinate topMargin, KDCoordinate rightMargin,
     KDCoordinate bottomMargin, KDCoordinate leftMargin) :
-  TableView(dataSource, topMargin, rightMargin, bottomMargin, leftMargin)
+  SimpleTableView(dataSource, topMargin, rightMargin, bottomMargin, leftMargin)
 {
 }
 
diff --git a/escher/src/table_view.cpp b/escher/src/simple_table_view.cpp
similarity index 71%
rename from escher/src/table_view.cpp
rename to escher/src/simple_table_view.cpp
index 75eca0379..4f7d3808f 100644
--- a/escher/src/table_view.cpp
+++ b/escher/src/simple_table_view.cpp
@@ -1,4 +1,4 @@
-#include <escher/table_view.h>
+#include <escher/simple_table_view.h>
 #include <escher/metric.h>
 
 extern "C" {
@@ -7,34 +7,34 @@ extern "C" {
 
 #define MIN(x,y) ((x)<(y) ? (x) : (y))
 
-void TableViewDataSource::willDisplayCellAtLocation(View * cell, int x, int y) {
+void SimpleTableViewDataSource::willDisplayCellAtLocation(View * cell, int x, int y) {
 }
 
 
-TableView::TableView(TableViewDataSource * dataSource, KDCoordinate topMargin, KDCoordinate rightMargin,
+SimpleTableView::SimpleTableView(SimpleTableViewDataSource * dataSource, KDCoordinate topMargin, KDCoordinate rightMargin,
     KDCoordinate bottomMargin, KDCoordinate leftMargin) :
   ScrollView(&m_contentView, topMargin, rightMargin, bottomMargin, leftMargin),
-  m_contentView(TableView::ContentView(this, dataSource))
+  m_contentView(SimpleTableView::ContentView(this, dataSource))
 {
 }
 
 // This method computes the minimal scrolling needed to properly display the
 // requested cell.
-void TableView::scrollToCell(int x, int y) {
+void SimpleTableView::scrollToCell(int x, int y) {
   m_contentView.scrollToCell(x, y);
 }
 
-View * TableView::cellAtLocation(int x, int y) {
+View * SimpleTableView::cellAtLocation(int x, int y) {
   return m_contentView.cellAtLocation(x, y);
 }
 
 #if ESCHER_VIEW_LOGGING
-const char * TableView::className() const {
-  return "TableView";
+const char * SimpleTableView::className() const {
+  return "SimpleTableView";
 }
 #endif
 
-void TableView::layoutSubviews() {
+void SimpleTableView::layoutSubviews() {
   // We only have to layout our contentView.
   // We will size it here, and ScrollView::layoutSubviews will position it.
 
@@ -44,31 +44,31 @@ void TableView::layoutSubviews() {
   ScrollView::layoutSubviews();
 }
 
-/* TableView::ContentView */
+/* SimpleTableView::ContentView */
 
-TableView::ContentView::ContentView(TableView * tableView, TableViewDataSource * dataSource) :
+SimpleTableView::ContentView::ContentView(SimpleTableView * tableView, SimpleTableViewDataSource * dataSource) :
   View(),
   m_tableView(tableView),
   m_dataSource(dataSource)
 {
 }
 
-KDCoordinate TableView::ContentView::realCellWidth() const {
+KDCoordinate SimpleTableView::ContentView::realCellWidth() const {
   int cellWidth = m_dataSource->cellWidth();
   cellWidth = cellWidth ? cellWidth : m_tableView->maxContentWidthDisplayableWithoutScrolling();
   return cellWidth;
 }
 
 
-KDCoordinate TableView::ContentView::height() const {
+KDCoordinate SimpleTableView::ContentView::height() const {
   return m_dataSource->numberOfRows() * m_dataSource->cellHeight();
 }
 
-KDCoordinate TableView::ContentView::width() const {
+KDCoordinate SimpleTableView::ContentView::width() const {
   return m_dataSource->numberOfColumns() * realCellWidth();
 }
 
-void TableView::ContentView::scrollToCell(int x, int y) const {
+void SimpleTableView::ContentView::scrollToCell(int x, int y) const {
   KDCoordinate contentOffsetX = m_tableView->contentOffset().x();
   KDCoordinate contentOffsetY = m_tableView->contentOffset().y();
   if (columnAtIndexIsBeforeFullyVisibleRange(x)) {
@@ -88,31 +88,31 @@ void TableView::ContentView::scrollToCell(int x, int y) const {
   m_tableView->setContentOffset(KDPoint(contentOffsetX, contentOffsetY));
 }
 
-View * TableView::ContentView::cellAtLocation(int x, int y) {
+View * SimpleTableView::ContentView::cellAtLocation(int x, int y) {
   int relativeX = x-columnsScrollingOffset();
   int relativeY = y-rowsScrollingOffset();
   return m_dataSource->reusableCell(relativeY*numberOfDisplayableColumns()+relativeX);
 }
 
 #if ESCHER_VIEW_LOGGING
-const char * TableView::ContentView::className() const {
+const char * SimpleTableView::ContentView::className() const {
   return "TableView::ContentView";
 }
 #endif
 
-int TableView::ContentView::numberOfSubviews() const {
+int SimpleTableView::ContentView::numberOfSubviews() const {
   int result = numberOfDisplayableRows() * numberOfDisplayableColumns();
   assert(result <= m_dataSource->reusableCellCount());
   return result;
 }
 
-View * TableView::ContentView::subviewAtIndex(int index) {
+View * SimpleTableView::ContentView::subviewAtIndex(int index) {
   assert(index >= 0);
   assert(index < m_dataSource->reusableCellCount());
   return m_dataSource->reusableCell(index);
 }
 
-void TableView::ContentView::layoutSubviews() {
+void SimpleTableView::ContentView::layoutSubviews() {
   int rowOffset = rowsScrollingOffset();
   int columnOffset = columnsScrollingOffset();
 
@@ -135,24 +135,24 @@ void TableView::ContentView::layoutSubviews() {
   }
 }
 
-int TableView::ContentView::numberOfFullyDisplayableRows() const {
+int SimpleTableView::ContentView::numberOfFullyDisplayableRows() const {
   // The number of displayable rows taking into accounts margins
   return m_tableView->maxContentHeightDisplayableWithoutScrolling()/m_dataSource->cellHeight();
 }
 
-int TableView::ContentView::numberOfFullyDisplayableColumns() const {
+int SimpleTableView::ContentView::numberOfFullyDisplayableColumns() const {
   // The number of displayable columns taking into accounts margins
   return m_tableView->maxContentWidthDisplayableWithoutScrolling()/m_dataSource->cellHeight();
 }
 
-int TableView::ContentView::numberOfDisplayableRows() const {
+int SimpleTableView::ContentView::numberOfDisplayableRows() const {
   return MIN(
     m_dataSource->numberOfRows(),
     m_tableView->bounds().height() / m_dataSource->cellHeight() + 2
   );
 }
 
-int TableView::ContentView::numberOfDisplayableColumns() const {
+int SimpleTableView::ContentView::numberOfDisplayableColumns() const {
   KDCoordinate width = realCellWidth();
   if (width == 0) {
     return 0;
@@ -163,14 +163,14 @@ int TableView::ContentView::numberOfDisplayableColumns() const {
   );
 }
 
-int TableView::ContentView::rowsScrollingOffset() const {
+int SimpleTableView::ContentView::rowsScrollingOffset() const {
   /* Here, we want to translate the offset at which our tableView is displaying
    * us into an integer offset we can use to ask cells to our data source. */
   KDCoordinate pixelScrollingOffset = -m_frame.y();
   return pixelScrollingOffset / m_dataSource->cellHeight();
 }
 
-int TableView::ContentView::columnsScrollingOffset() const {
+int SimpleTableView::ContentView::columnsScrollingOffset() const {
   /* Here, we want to translate the offset at which our tableView is displaying
    * us into an integer offset we can use to ask cells to our data source. */
   KDCoordinate width = realCellWidth();
@@ -181,20 +181,20 @@ int TableView::ContentView::columnsScrollingOffset() const {
   return pixelScrollingOffset / width;
 }
 
-bool TableView::ContentView::rowAtIndexIsBeforeFullyVisibleRange(int index) const {
+bool SimpleTableView::ContentView::rowAtIndexIsBeforeFullyVisibleRange(int index) const {
   return index <= rowsScrollingOffset();
 }
 
-bool TableView::ContentView::columnAtIndexIsBeforeFullyVisibleRange(int index) const {
+bool SimpleTableView::ContentView::columnAtIndexIsBeforeFullyVisibleRange(int index) const {
   return index <= columnsScrollingOffset();
 }
 
-bool TableView::ContentView::rowAtIndexIsAfterFullyVisibleRange(int index) const {
+bool SimpleTableView::ContentView::rowAtIndexIsAfterFullyVisibleRange(int index) const {
   int relativeIndex = index - rowsScrollingOffset();
   return (relativeIndex >= numberOfFullyDisplayableRows());
 }
 
-bool TableView::ContentView::columnAtIndexIsAfterFullyVisibleRange(int index) const {
+bool SimpleTableView::ContentView::columnAtIndexIsAfterFullyVisibleRange(int index) const {
   int relativeIndex = index - columnsScrollingOffset();
   return (relativeIndex >= numberOfFullyDisplayableColumns());
 }