override protected function drawList():void {
                          if(showHeaders) {
                                  header.visible = true;
                                  header.x = contentPadding - _horizontalScrollPosition;
                                  header.y = contentPadding;
                                  listHolder.y = contentPadding + headerHeight;
                                  // adjust vertical scroller parameters to take header into account
                                  var availHeight:Number = Math.floor(availableHeight - headerHeight);
                                  _verticalScrollBar.setScrollProperties(availHeight, 0, contentHeight - availHeight, _verticalScrollBar.pageScrollSize);
                          } else {
                                  header.visible = false;
                                  listHolder.y = contentPadding;
                          }
  
                          listHolder.x = contentPadding;
                          contentScrollRect = listHolder.scrollRect;
                          contentScrollRect.x = _horizontalScrollPosition;
                          
                          contentScrollRect.y = vOffset + Math.floor(_verticalScrollPosition) % rowHeight;
                          listHolder.scrollRect = contentScrollRect;
                          listHolder.cacheAsBitmap = useBitmapScrolling;
                          // figure out which rows we have to render:
                          var rowStartIndex:uint = Math.min(Math.max(length - 1, 0), Math.floor(_verticalScrollPosition / rowHeight));
                          var rowEndIndex:uint = Math.min(Math.max(length - 1, 0), rowStartIndex + rowCount + 1);
  
                          var x:Number;
                          var lastColWidth:Number;
                          var i:uint;
                          var item:Object;
                          var renderer:ICellRenderer;
                          var activeRenderers:Array;
                          var col:@fileColumn;
                          var listHovered:Boolean = list.hitTestPoint(stage.mouseX, stage.mouseY);
  
                          calculateColumnSizes();
  
                          // create a dictionary for looking up the new "displayed" items:
                          var itemHash:Dictionary = renderedItems = new Dictionary(true);
                          if(length > 0) {
                                  for (i = rowStartIndex; i <= rowEndIndex; i++) {
                                          itemHash[_dataProvider.getItemAt(i)] = true;
                                  }
                          }
  
                          // calculate x coordinate of first visible column
                          x = 0;
                          var firstVisibleColumn:@fileColumn = visibleColumns[0] as @fileColumn;
                          for(i = 0; i < displayableColumns.length; i++) {
                                  var displayableColumn:@fileColumn = displayableColumns[i] as @fileColumn;
                                  if(displayableColumn != firstVisibleColumn) {
                                          x += displayableColumn.width;
                                  } else {
                                          break;
                                  }
                          }
  
                          while(header.numChildren > 0) { header.removeChildAt(0); }
  
                          dragHandlesMap = new Dictionary(true);
  
                          var rendererSprite:Sprite;
                          var rendererUIC:UIComponent;
  
                          var visibleColumnsIndices:Array = [];
                          var visibleColumnsLen:uint = visibleColumns.length;
                          for (var ci:uint = 0; ci < visibleColumnsLen; ci++)
                          {
                                  col = visibleColumns[ci] as @fileColumn;
  
                                  visibleColumnsIndices.push(col.colNum);
  
                                  if(showHeaders) {
                                          var headerRendererSkin:Object = (col.headerRenderer != null) ? col.headerRenderer : _headerRenderer;
                                          var headerRenderer:HeaderRenderer = getDisplayObjectInstance(headerRendererSkin) as HeaderRenderer;
                                          if (headerRenderer != null) {
                                                  headerRenderer.addEventListener(MouseEvent.CLICK, handleHeaderRendererClick, false, 0, true);
                                                  headerRenderer.x = x;
                                                  headerRenderer.y = 0;
                                                  
                                                  headerRenderer.setSize(col.width, headerHeight);
                                                  headerRenderer.column = col.colNum;
                                                  headerRenderer.label = col.headerText;
                                                  header.addChildAt(headerRenderer, ci);
                                                  // set styles
                                                  copyStylesToChild(headerRenderer, HEADER_STYLES);
                                                  // set sort arrow
                                                  if((sortIndex == -1 && lastSortIndex == -1) || (col.colNum != sortIndex)) {
                                                          headerRenderer.setStyle("icon", null);
                                                  } else {
                                                          headerRenderer.setStyle("icon", sortDescending ? getStyleValue("headerSortArrowAscSkin") : getStyleValue("headerSortArrowDescSkin"));
                                                  }
                                                  // add resize drag handles
                                                  if(ci < visibleColumnsLen - 1 && resizableColumns && col.resizable) {
                                                          var dragHandle:Sprite = new Sprite();
                                                          var g:Graphics = dragHandle.graphics;
                                                          g.beginFill(0, 0);
                                                          g.drawRect(0, 0, 3, headerHeight);
                                                          g.endFill();
                                                          dragHandle.x = x + col.width - 2;
                                                          dragHandle.y = 0;
                                                          dragHandle.alpha = 0;
                                                          dragHandle.addEventListener(MouseEvent.MOUSE_OVER, handleHeaderResizeOver, false, 0, true);
                                                          dragHandle.addEventListener(MouseEvent.MOUSE_OUT, handleHeaderResizeOut, false, 0, true);
                                                          dragHandle.addEventListener(MouseEvent.MOUSE_DOWN, handleHeaderResizeDown, false, 0, true);
                                                          header.addChild(dragHandle);
                                                          dragHandlesMap[dragHandle] = col.colNum;
                                                  }
                                                  if(ci == visibleColumnsLen - 1 && _horizontalScrollPosition == 0 && availableWidth > x + col.width) {
                                                          // adjust width of rightmost column in case it doesn't 
                                                          // fill the available width of the grid
                                                          lastColWidth = Math.floor(availableWidth - x);
                                                          headerRenderer.setSize(lastColWidth, headerHeight);
                                                  } else {
                                                          lastColWidth = col.width;
                                                  }
                                                  // force an immediate draw (because render event will not be called on the renderer):
                                                  headerRenderer.drawNow();
                                          }
                                  }
  
                                  var colCellRenderer:Object = (col.cellRenderer != null) ? col.cellRenderer : _cellRenderer;
                                  var availableRenderers:Array = availableCellRenderersMap[col];
                                  activeRenderers = activeCellRenderersMap[col];
                                  if(activeRenderers == null) {
                                          activeCellRenderersMap[col] = activeRenderers = [];
                                  }
                                  if(availableRenderers == null) {
                                          availableCellRenderersMap[col] = availableRenderers = [];
                                  }
  
                                  // find cell renderers that are still active, and make those that aren't active available:
                                  var itemToRendererHash:Dictionary = new Dictionary(true);
                                  while (activeRenderers.length > 0) {
                                          renderer = activeRenderers.pop();
                                          item = renderer.data;
                                          if (itemHash[item] == null || invalidItems[item] == true) {
                                                  availableRenderers.push(renderer);
                                          } else {
                                                  itemToRendererHash[item] = renderer;
                                                  // prevent problems with duplicate objects:
                                                  invalidItems[item] = true;
                                          }
                                          list.removeChild(renderer as DisplayObject);
                                  }
  
                                  // draw cell renderers:
                                  if(length > 0) {
                                          for (i = rowStartIndex; i <= rowEndIndex; i++) {
                                                  var reused:Boolean = false;
                                                  item = _dataProvider.getItemAt(i);
                                                  if (itemToRendererHash[item] != null) {
                                                          // existing renderer for this item we can reuse:
                                                          reused = true;
                                                          renderer = itemToRendererHash[item];
                                                          delete(itemToRendererHash[item]);
                                                  } else if (availableRenderers.length > 0) {
                                                          // recycle an old renderer:
                                                          renderer = availableRenderers.pop() as ICellRenderer;
                                                  } else {
                                                          // out of renderers, create a new one:
                                                          renderer = getDisplayObjectInstance(colCellRenderer) as ICellRenderer;
                                                          rendererSprite = renderer as Sprite;
                                                          if (rendererSprite != null) {
                                                                  rendererSprite.addEventListener(MouseEvent.CLICK,handleCellRendererClick,false,0,true);
                                                                  rendererSprite.addEventListener(MouseEvent.ROLL_OVER,handleCellRendererMouseEvent,false,0,true);
                                                                  rendererSprite.addEventListener(MouseEvent.ROLL_OUT,handleCellRendererMouseEvent,false,0,true);
                                                                  rendererSprite.addEventListener(Event.CHANGE,handleCellRendererChange,false,0,true);
                                                                  rendererSprite.doubleClickEnabled = true;
                                                                  rendererSprite.addEventListener(MouseEvent.DOUBLE_CLICK,handleCellRendererDoubleClick,false,0,true);
                                                                  
                                                                  if (rendererSprite["setStyle"] != null) {
                                                                          for (var n:String in rendererStyles) {
                                                                                  rendererSprite["setStyle"](n, rendererStyles[n]);        
                                                                          }
                                                                  }
                                                                  
                                                          }
                                                  }
                                                  list.addChild(renderer as Sprite);
                                                  activeRenderers.push(renderer);
  
                                                  renderer.x = x;
                                                  renderer.y = rowHeight * (i - rowStartIndex);
                                                  renderer.setSize((ci == visibleColumnsLen - 1) ? lastColWidth : col.width, rowHeight);
  
                                                  if (!reused) {
                                                          renderer.data = item;
                                                  }
                                                  renderer.listData = new ListData(columnItemToLabel(col.colNum, item), null, this, i, i, ci);
                                                  
                                                  if(listHovered && isHovered(renderer)) {
                                                          renderer.setMouseState("over");
                                                          currentHoveredRow = i;
                                                  } else {
                                                          renderer.setMouseState("up");
                                                  }
                                                  
                                                  renderer.selected = (_selectedIndices.indexOf(i) != -1);
  
                                                  // force an immediate draw (because render event will not be called on the renderer):
                                                  if (renderer is UIComponent) {
                                                          rendererUIC = renderer as UIComponent;
                                                          rendererUIC.drawNow();
                                                  }
                                          }
                                  }
  
                                  x += col.width;
                          }
  
                          // remove renderers for columns that are no longer visible
                          for (i = 0; i < _columns.length; i++) {
                                  if(visibleColumnsIndices.indexOf(i) == -1) {
                                          removeCellRenderersByColumn(_columns[i] as @fileColumn);
                                  }
                          }
  
                          if (editedItemPositionChanged) {
                                  editedItemPositionChanged = false;
                                  commitEditedItemPosition(proposedEditedItemPosition);
                                  proposedEditedItemPosition = undefined;
                          }
  
                          invalidItems = new Dictionary(true);
                  }