Back to index

nux  3.0.0
TabView.cpp
Go to the documentation of this file.
00001 /*
00002  * Copyright 2010 Inalogic® Inc.
00003  *
00004  * This program is free software: you can redistribute it and/or modify it
00005  * under the terms of the GNU Lesser General Public License, as
00006  * published by the  Free Software Foundation; either version 2.1 or 3.0
00007  * of the License.
00008  *
00009  * This program is distributed in the hope that it will be useful, but
00010  * WITHOUT ANY WARRANTY; without even the implied warranties of
00011  * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
00012  * PURPOSE.  See the applicable version of the GNU Lesser General Public
00013  * License for more details.
00014  *
00015  * You should have received a copy of both the GNU Lesser General Public
00016  * License along with this program. If not, see <http://www.gnu.org/licenses/>
00017  *
00018  * Authored by: Jay Taoko <jaytaoko@inalogic.com>
00019  *
00020  */
00021 
00022 
00023 #include "Nux.h"
00024 #include "TabView.h"
00025 #include "Layout.h"
00026 #include "HLayout.h"
00027 #include "VLayout.h"
00028 
00029 namespace nux
00030 {
00031 
00032   int TabView::TAB_BUTTON_WIDTH   = 12;
00033   int TabView::TAB_BUTTON_HEIGHT  = 20;
00034   int TabView::TAB_HEIGHT         = 24;
00035   int TabView::TAB_X_BORDER       = 4;
00036   int TabView::TAB_Y_BORDER       = 4;
00037 
00038   Color TabView::TAB_HEADER_BACKGROUND_COLOR    = Color(0xFF000000);
00039   Color TabView::TAB_BACKGROUND_COLOR           = Color(0xFF191919);
00040   Color TabView::TAB_HEADER_COLOR               = Color(0xFF333333);
00041   Color TabView::TAB_HEADER_FOCUS_COLOR         = Color(0xFF5D5D5D);
00042 
00043   TabView::TabElement::TabElement(NString TabName, Layout *TabLayout)
00044   {
00045     _index = 0;
00046     _tab_name = TabName;
00047     _tab_content_layout = TabLayout;
00048     _tab_area = new InputArea(NUX_TRACKER_LOCATION);
00049 
00050     _tab_content_layout->Reference();
00051     _tab_area->Reference();
00052   }
00053 
00054   TabView::TabElement::~TabElement()
00055   {
00056     _index = 0;
00057     _tab_content_layout->UnReference();
00058     _tab_area->UnReference();
00059   }
00060 
00061   void TabView::TabElement::SetIndex(int index)
00062   {
00063     _index = index;
00064   }
00065 
00066   int TabView::TabElement::GetIndex() const
00067   {
00068     return _index;
00069   }
00070 
00071   void TabView::TabElement::SetGeometry(const Geometry &geo)
00072   {
00073     _tab_area->SetGeometry(geo);
00074   }
00075 
00076   Geometry const& TabView::TabElement::GetGeometry() const
00077   {
00078     return _tab_area->GetGeometry();
00079   }
00080 
00081   const NString &TabView::TabElement::GetName() const
00082   {
00083     return _tab_name;
00084   }
00085 
00086   TabView::TabView(NUX_FILE_LINE_DECL)
00087     :   View(NUX_FILE_LINE_PARAM)
00088   {
00089     _scroll_right           = NULL;
00090     _scroll_left           = NULL;
00091     _visible_tab_content_layout      = NULL;
00092     _tabview_heads_layout         = NULL;
00093     _tabview_scroll_button_layout  = NULL;
00094 
00095     m_FocusTabIndex     = 0;
00096     m_TabPositionOffset = 0;
00097     m_DrawBackgroundOnPreviousGeometry = false;
00098 
00099     _tabview_heads_layout         = new HLayout(NUX_TRACKER_LOCATION);
00100     //_tabview_heads_layout->SetParentObject(this);
00101     _tabview_scroll_button_layout  = new HLayout(NUX_TRACKER_LOCATION);
00102     _tabview_scroll_button_layout->SetParentObject(this);
00103     _scroll_right           = new InputArea(NUX_TRACKER_LOCATION);
00104     _scroll_left           = new InputArea(NUX_TRACKER_LOCATION);
00105 
00106     _scroll_right->SetMinimumSize(TAB_BUTTON_WIDTH, TAB_BUTTON_HEIGHT);
00107     _scroll_left->SetMinimumSize(TAB_BUTTON_WIDTH, TAB_BUTTON_HEIGHT);
00108     _scroll_right->SetMaximumSize(TAB_BUTTON_WIDTH, TAB_BUTTON_HEIGHT);
00109     _scroll_left->SetMaximumSize(TAB_BUTTON_WIDTH, TAB_BUTTON_HEIGHT);
00110 
00111     _scroll_right->mouse_enter.connect(sigc::mem_fun(this, &TabView::RecvMouseEnter));
00112     _scroll_right->mouse_leave.connect(sigc::mem_fun(this, &TabView::RecvMouseLeave));
00113     _scroll_left->mouse_enter.connect(sigc::mem_fun(this, &TabView::RecvMouseEnter));
00114     _scroll_left->mouse_leave.connect(sigc::mem_fun(this, &TabView::RecvMouseLeave));
00115 
00116     _scroll_right->mouse_down.connect(sigc::mem_fun(this, &TabView::RecvTabRightMouseDown));
00117     _scroll_left->mouse_down.connect(sigc::mem_fun(this, &TabView::RecvTabLeftMouseDown));
00118     _scroll_right->mouse_up.connect(sigc::mem_fun(this, &TabView::RecvTabButtonMouseUp));
00119     _scroll_left->mouse_up.connect(sigc::mem_fun(this, &TabView::RecvTabButtonMouseUp));
00120 
00121     _tabview_scroll_button_layout->AddView(_scroll_left, 1, eCenter);
00122     _tabview_scroll_button_layout->AddView(_scroll_right, 1, eCenter);
00123 
00124 
00125     tabright_callback = new TimerFunctor;
00126     tabright_callback->time_expires.connect(sigc::mem_fun(this, &TabView::RecvTabRightTimerExpired));
00127     tableft_callback = new TimerFunctor;
00128     tableft_callback->time_expires.connect(sigc::mem_fun(this, &TabView::RecvTabLeftTimerExpired));
00129   }
00130 
00131   TabView::~TabView()
00132   {
00133     _tabview_heads_layout->UnReference();
00134     _tabview_scroll_button_layout->UnReference();
00135     RemoveCompositionLayout();
00136     delete(tabright_callback);
00137     delete(tableft_callback);
00138     
00139     std::vector<TabElement *>::iterator it;
00140 
00141     for (it = _tab_array.begin(); it != _tab_array.end(); it++)
00142     {
00143       (*it)->_tab_area->UnParentObject();
00144       (*it)->_tab_content_layout->UnParentObject();
00145       delete(*it);
00146     }
00147 
00148     _tab_array.clear();
00149   }
00150 
00151   Area* TabView::FindAreaUnderMouse(const Point& mouse_position, NuxEventType event_type)
00152   {
00153     bool mouse_inside = TestMousePointerInclusionFilterMouseWheel(mouse_position, event_type);
00154 
00155     if (mouse_inside == false)
00156       return NULL;
00157 
00158     NUX_RETURN_VALUE_IF_TRUE(_scroll_right->TestMousePointerInclusion(mouse_position, event_type), _scroll_right);
00159     NUX_RETURN_VALUE_IF_TRUE(_scroll_left->TestMousePointerInclusion(mouse_position, event_type), _scroll_left);
00160 
00161     unsigned int vector_size = (unsigned int) _tab_array.size();
00162     for (unsigned int i = 0; i < vector_size; i++)
00163     {
00164       NUX_RETURN_VALUE_IF_TRUE(_tab_array[i]->_tab_area->TestMousePointerInclusion(mouse_position, event_type), _tab_array[i]->_tab_area);
00165     }
00166 
00167     if (_visible_tab_content_layout)
00168     {
00169       nuxAssert(_visible_tab_content_layout->IsLayout());
00170       Area* found_area = _visible_tab_content_layout->FindAreaUnderMouse(mouse_position, event_type);
00171       if (found_area)
00172         return found_area;
00173     }
00174 
00175     return this;
00176   }
00177 
00178 
00179   void TabView::Draw(GraphicsEngine &graphics_engine, bool force_draw)
00180   {
00181     if (m_DrawBackgroundOnPreviousGeometry)
00182     {
00183       GetPainter().PaintBackground(graphics_engine, m_PreviousGeometry);
00184       m_DrawBackgroundOnPreviousGeometry = false;
00185     }
00186 
00187     graphics_engine.PushClippingRectangle(GetGeometry());
00188     Geometry base = GetGeometry();
00189 
00190     GetPainter().PushDrawShapeLayer(graphics_engine, Geometry(base.x, base.y, base.GetWidth(), TAB_HEIGHT), eSHAPE_CORNER_ROUND4, TAB_HEADER_BACKGROUND_COLOR, eCornerTopLeft | eCornerTopRight);
00191 
00192     if (_visible_tab_content_layout)
00193       _visible_tab_content_layout->QueueDraw();
00194 
00195     unsigned int vector_size = (unsigned int) _tab_array.size();
00196 
00197     Geometry geo = GetGeometry();
00198     Geometry clip_geo;
00199     clip_geo.SetX(geo.x);
00200     clip_geo.SetY(geo.y);
00201     clip_geo.SetWidth(geo.GetWidth() - 2 * TAB_BUTTON_WIDTH);
00202     clip_geo.SetHeight(_tabview_heads_layout->GetBaseHeight());
00203 
00204     graphics_engine.PushClippingRectangle(clip_geo);
00205 
00206     for (unsigned int i = 0; i < vector_size; i++)
00207     {
00208       Geometry tab_geo = _tab_array[i]->_tab_area->GetGeometry();
00209       const char *tab_text = _tab_array[i]->GetName().GetTCharPtr();
00210 
00211       if (_tab_array[i]->_index == m_FocusTabIndex)
00212       {
00213         tab_geo.OffsetSize(-2, 0);
00214         GetPainter().PaintShapeCorner(graphics_engine, tab_geo, TAB_HEADER_FOCUS_COLOR, eSHAPE_CORNER_ROUND4, eCornerTopLeft | eCornerTopRight, false);
00215         GetPainter().PaintTextLineStatic(graphics_engine, GetSysBoldFont(), tab_geo, tab_text, Color(0xFFFFFFFF), true, eAlignTextCenter);
00216       }
00217       else
00218       {
00219         tab_geo.OffsetSize(-2, 0);
00220         GetPainter().PaintShapeCorner(graphics_engine, tab_geo, TAB_HEADER_COLOR, eSHAPE_CORNER_ROUND4, eCornerTopLeft | eCornerTopRight, false);
00221         GetPainter().PaintTextLineStatic(graphics_engine, GetSysBoldFont(), tab_geo, tab_text, Color(0xFF000000), true, eAlignTextCenter);
00222       }
00223     }
00224 
00225     graphics_engine.PopClippingRectangle();
00226 
00227     GetPainter().PaintShapeCorner(graphics_engine, Geometry(base.x, base.y + TAB_HEIGHT, base.GetWidth(), base.GetHeight() - TAB_HEIGHT),
00228                                TAB_BACKGROUND_COLOR, eSHAPE_CORNER_ROUND4, eCornerBottomLeft | eCornerBottomRight, false);
00229 
00230     GetPainter().Paint2DQuadColor(graphics_engine, _scroll_right->GetGeometry(), TAB_HEADER_BACKGROUND_COLOR);
00231     GeometryPositioning gp(eHACenter, eVACenter);
00232     Geometry GeoPo = ComputeGeometryPositioning(_scroll_right->GetGeometry(), GetTheme().GetImageGeometry(eTAB_RIGHT), gp);
00233 
00234     if (_scroll_right->IsMouseInside())
00235       GetPainter().PaintShape(graphics_engine, GeoPo, Color(0xFFFFFFFF), eTAB_RIGHT);
00236     else
00237       GetPainter().PaintShape(graphics_engine, GeoPo, TAB_HEADER_FOCUS_COLOR, eTAB_RIGHT);
00238 
00239     GetPainter().Paint2DQuadColor(graphics_engine, _scroll_left->GetGeometry(), TAB_HEADER_BACKGROUND_COLOR);
00240     gp.SetAlignment(eHACenter, eVACenter);
00241     GeoPo = ComputeGeometryPositioning(_scroll_left->GetGeometry(), GetTheme().GetImageGeometry(eTAB_LEFT), gp);
00242 
00243     if (_scroll_left->IsMouseInside())
00244       GetPainter().PaintShape(graphics_engine, GeoPo, Color(0xFFFFFFFF), eTAB_LEFT);
00245     else
00246       GetPainter().PaintShape(graphics_engine, GeoPo, TAB_HEADER_FOCUS_COLOR, eTAB_LEFT);
00247 
00248     GetPainter().PopBackground();
00249     graphics_engine.PopClippingRectangle();
00250   }
00251 
00252   void TabView::DrawContent(GraphicsEngine &graphics_engine, bool force_draw)
00253   {
00254     Geometry base = GetGeometry();
00255 
00256     graphics_engine.PushClippingRectangle(GetGeometry());
00257     GetPainter().PushShapeLayer(graphics_engine, Geometry(base.x, base.y + TAB_HEIGHT, base.GetWidth(), base.GetHeight() - TAB_HEIGHT),
00258                              eSHAPE_CORNER_ROUND4, TAB_BACKGROUND_COLOR, eCornerBottomLeft | eCornerBottomRight);
00259 
00260     if (_visible_tab_content_layout)
00261     {
00262       graphics_engine.PushClippingRectangle(_visible_tab_content_layout->GetGeometry());
00263       _visible_tab_content_layout->ProcessDraw(graphics_engine, force_draw);
00264       graphics_engine.PopClippingRectangle();
00265     }
00266 
00267     GetPainter().PopBackground();
00268     graphics_engine.PopClippingRectangle();
00269   }
00270 
00271   void TabView::PostDraw(GraphicsEngine &graphics_engine, bool force_draw)
00272   {
00273 
00274   }
00275 
00276   void TabView::PreLayoutManagement()
00277   {
00278     // Give the managed layout appropriate size and position..
00279     if (view_layout_)
00280     {
00281       Geometry layout_geo = GetGeometry();
00282       layout_geo.OffsetPosition(TAB_X_BORDER, TAB_HEIGHT);
00283       layout_geo.OffsetSize(-2 * TAB_X_BORDER, - (TAB_HEIGHT) - TAB_Y_BORDER);
00284       view_layout_->SetGeometry(layout_geo);
00285     }
00286   }
00287 
00288   long TabView::PostLayoutManagement(long LayoutResult)
00289   {
00290     // Set the geometry of the control to be the same as the managed layout.
00291     // Only the size is changed. The position of the composition layout hasn't
00292     // been changed by ComputeContentSize.
00293     if (view_layout_)
00294     {
00295       Geometry base = view_layout_->GetGeometry();
00296       base.OffsetPosition(-TAB_X_BORDER, -TAB_HEIGHT);
00297       base.OffsetSize(2 * TAB_X_BORDER, TAB_HEIGHT + TAB_Y_BORDER);
00298       Area::SetGeometry(base);
00299     }
00300 
00301     Geometry base = GetGeometry();
00302 
00303     int tab_x = view_layout_->GetGeometry().x + view_layout_->GetGeometry().GetWidth() - 2 * TAB_BUTTON_WIDTH;
00304     int tab_y = base.y;
00305 
00306     _scroll_left->SetBaseXY(tab_x, tab_y);
00307     _scroll_left->SetBaseSize(TAB_BUTTON_WIDTH, TAB_BUTTON_HEIGHT);
00308     _scroll_right->SetBaseXY(tab_x + TAB_BUTTON_WIDTH, tab_y);
00309     _scroll_right->SetBaseSize(TAB_BUTTON_WIDTH, TAB_BUTTON_HEIGHT);
00310 
00311     _tabview_heads_layout->SetBaseY(tab_y);
00312     _tabview_heads_layout->SetBaseHeight(TAB_HEIGHT);
00313     TranslateTabLayout(0);
00314 
00315     _tabview_scroll_button_layout->SetBaseXY(tab_x, tab_y);
00316     _tabview_scroll_button_layout->SetBaseSize(2 * TAB_BUTTON_WIDTH, TAB_HEIGHT);
00317     GetWindowThread()->ComputeElementLayout(_tabview_scroll_button_layout);
00318 
00319     if (_visible_tab_content_layout)
00320     {
00321 //        _visible_tab_content_layout->SetGeometry(view_layout_->GetGeometry());
00322 //        GetWindowThread()->ComputeElementLayout(_visible_tab_content_layout);
00323       _visible_tab_content_layout->QueueDraw();
00324     }
00325 
00326     return LayoutResult;
00327   }
00328 
00329   void TabView::ComputeContentPosition(float offsetX, float offsetY)
00330   {
00331     if (view_layout_)
00332     {
00333       view_layout_->SetBaseX(GetBaseX() + TAB_X_BORDER);
00334       view_layout_->SetBaseY(GetBaseY() + TAB_HEIGHT);
00335       view_layout_->ComputeContentPosition(offsetX, offsetY);
00336     }
00337   }
00338 
00339 
00340   void TabView::AddTab(const char *tab_name, Layout *tab_layout)
00341   {
00342     if (tab_layout == 0)
00343       return;
00344 
00345     TabElement *Tab = new TabElement(tab_name, tab_layout);
00346 
00347     Tab->SetIndex(_tab_array.size());
00348 
00349     if (Tab->GetIndex() == 0)
00350     {
00351       m_FocusTabIndex = 0;
00352       _visible_tab_content_layout = Tab->_tab_content_layout;
00353       //_visible_tab_content_layout->SetGeometry(view_layout_->GetGeometry());
00354       SetCompositionLayout(_visible_tab_content_layout);
00355       GetWindowThread()->ComputeElementLayout(this);
00356     }
00357 
00358     Tab->_tab_area->SetMinimumSize(6 + GetSysBoldFont()->GetStringWidth(tab_name), PRACTICAL_WIDGET_HEIGHT);
00359     Tab->_tab_area->SetMaximumSize(6 + GetSysBoldFont()->GetStringWidth(tab_name), PRACTICAL_WIDGET_HEIGHT);
00360 
00361     Tab->_tab_area->mouse_down.connect(sigc::bind(sigc::mem_fun(this, &TabView::RecvTabMouseDown), Tab));
00362     Tab->_tab_area->mouse_up.connect(sigc::bind(sigc::mem_fun(this, &TabView::RecvTabMouseUp), Tab));
00363 
00364     _tabview_heads_layout->AddView(Tab->_tab_area, 1, eCenter);
00365     GetWindowThread()->ComputeElementLayout(_tabview_heads_layout);
00366 
00367     _tab_array.push_back(Tab);
00368   }
00369 
00370   void TabView::SetActiveTad(int index)
00371   {
00372     if (index >= (int) _tab_array.size())
00373     {
00374       m_FocusTabIndex = (int) _tab_array.size() - 1;
00375     }
00376     else
00377     {
00378       m_FocusTabIndex = index;
00379     }
00380 
00381     _visible_tab_content_layout = _tab_array[m_FocusTabIndex]->_tab_content_layout;
00382 
00383     if (_visible_tab_content_layout)
00384       SetCompositionLayout(_visible_tab_content_layout);
00385 
00386     GetWindowThread()->ComputeElementLayout(this);
00387 
00388     sigTabChanged(this);
00389     sigTabIndexChanged(m_FocusTabIndex);
00390 
00391     QueueDraw();
00392   }
00393 
00394   void TabView::TranslateLeft(int x, int y, unsigned long button_flags, unsigned long key_flags)
00395   {
00396     TranslateTabLayout(-5);
00397   }
00398 
00399   void TabView::TranslateRight(int x, int y, unsigned long button_flags, unsigned long key_flags)
00400   {
00401     TranslateTabLayout(5);
00402   }
00403 
00404   void TabView::TranslateTabLayout(int offset)
00405   {
00406 //    if ((m_TabPositionOffset == 0) && (offset > 0))
00407 //        return;
00408 
00409     m_TabPositionOffset += offset;
00410     int lx = view_layout_->GetBaseX() + m_TabPositionOffset;
00411 
00412     if (lx > view_layout_->GetBaseX())
00413     {
00414       // end of scroll left;
00415       m_TabPositionOffset = 0;
00416       lx = view_layout_->GetBaseX() + m_TabPositionOffset;
00417     }
00418 
00419     if (lx + _tabview_heads_layout->GetBaseWidth() < view_layout_->GetBaseX() +
00420         view_layout_->GetBaseWidth() - 2 * TAB_BUTTON_WIDTH)
00421     {
00422 
00423       lx = (view_layout_->GetBaseX() +
00424             view_layout_->GetBaseWidth() - 2 * TAB_BUTTON_WIDTH) - _tabview_heads_layout->GetBaseWidth();
00425 
00426 
00427       if (lx > view_layout_->GetBaseX())
00428       {
00429         m_TabPositionOffset = 0;
00430         lx = view_layout_->GetBaseX() + m_TabPositionOffset;
00431       }
00432       else
00433         m_TabPositionOffset = - (view_layout_->GetBaseX() - lx);
00434     }
00435 
00436     _tabview_heads_layout->SetBaseX(lx);
00437     GetWindowThread()->ComputeElementLayout(_tabview_heads_layout);
00438     QueueDraw();
00439 
00440   }
00441 
00442   void TabView::RecvTabMouseDown(int x, int y, unsigned long button_flags, unsigned long key_flags, TabElement *tab)
00443   {
00444     m_FocusTabIndex = tab->_index;
00445     _visible_tab_content_layout = tab->_tab_content_layout;
00446 
00447     if (_visible_tab_content_layout)
00448     {
00449       SetCompositionLayout(_visible_tab_content_layout);
00450     }
00451 
00452     //_visible_tab_content_layout->SetGeometry(view_layout_->GetGeometry());
00453 
00454     m_PreviousGeometry = GetGeometry();
00455 
00456     int PrevWidth = GetBaseWidth();
00457     int PrevHeight = GetBaseHeight();
00458 
00459     GetWindowThread()->ComputeElementLayout(this, true);
00460 
00461 
00462     int NewWidth = GetBaseWidth();
00463     int NewHeight = GetBaseHeight();
00464 
00465     if ((NewWidth != PrevWidth) ||
00466          (NewHeight != PrevHeight))
00467     {
00468       // We need to draw the background on the previous size of the Table if its
00469       // size is set to match the content(IsSizeMatchContent) and an item is close.
00470       //m_PreviousGeometry;
00471       m_DrawBackgroundOnPreviousGeometry = true;
00472     }
00473 
00474     m_DrawBackgroundOnPreviousGeometry = true;
00475 
00476     sigTabChanged(this);
00477     sigTabIndexChanged(m_FocusTabIndex);
00478     QueueDraw();
00479   }
00480 
00481   void TabView::RecvTabMouseUp(int x, int y, unsigned long button_flags, unsigned long key_flags, TabElement *tab)
00482   {
00483 
00484   }
00485 
00486   void TabView::RecvMouseEnter(int x, int y, unsigned long button_flags, unsigned long key_flags)
00487   {
00488     QueueDraw();
00489   }
00490 
00491   void TabView::RecvMouseLeave(int x, int y, unsigned long button_flags, unsigned long key_flags)
00492   {
00493     QueueDraw();
00494   }
00495 
00496   void TabView::RecvTabRightMouseDown(int x, int y, unsigned long button_flags, unsigned long key_flags)
00497   {
00498     RecvTabRightTimerExpired(tabright_callback);
00499   }
00500 
00501   void TabView::RecvTabLeftMouseDown(int x, int y, unsigned long button_flags, unsigned long key_flags)
00502   {
00503     RecvTabLeftTimerExpired(tableft_callback);
00504   }
00505 
00506   void TabView::RecvTabButtonMouseUp(int x, int y, unsigned long button_flags, unsigned long key_flags)
00507   {
00508     if (m_TabRightTimerHandler.IsValid())
00509       GetTimer().RemoveTimerHandler(m_TabRightTimerHandler);
00510 
00511     if (m_TabLeftTimerHandler.IsValid())
00512       GetTimer().RemoveTimerHandler(m_TabLeftTimerHandler);
00513 
00514     m_TabRightTimerHandler = 0;
00515     m_TabLeftTimerHandler = 0;
00516   }
00517 
00518   void TabView::RecvTabRightTimerExpired(void *v)
00519   {
00520     TranslateTabLayout(-10);
00521     m_TabRightTimerHandler = GetTimer().AddTimerHandler(10, tabright_callback, this);
00522   }
00523 
00524   void TabView::RecvTabLeftTimerExpired(void *v)
00525   {
00526     TranslateTabLayout(10);
00527     m_TabLeftTimerHandler = GetTimer().AddTimerHandler(10, tableft_callback, this);
00528   }
00529 
00530   bool TabView::AcceptKeyNavFocus()
00531   {
00532     return false;
00533   }
00534 }