override protected function drawList():void {
                          // these vars get reused in different loops:
                          var i:uint;
                          var itemIndex:uint;
                          var item:Object;
                          var renderer:ICellRenderer;
                          var rows:uint = rowCount;
                          var cols:uint = columnCount;
                          var colW:Number = columnWidth;
                          var rowH:Number = rowHeight;
                          var baseCol:Number = 0;
                          var baseRow:Number = 0;
                          var col:uint;
                          var row:uint;
  
                          listHolder.x = listHolder.y = contentPadding;
  
                          // set horizontal scroll:
                          contentScrollRect = listHolder.scrollRect;
                          contentScrollRect.x = Math.floor(_horizontalScrollPosition)\%colW;
  
                          // set pixel scroll:
                          contentScrollRect.y = Math.floor(_verticalScrollPosition)\%rowH;
                          listHolder.scrollRect = contentScrollRect;
                          
                          listHolder.cacheAsBitmap = useBitmapScrolling;
                          
                          // figure out what we have to render, and where:
                          var items:Array = [];
                          if (_scrollDirection == ScrollBarDirection.HORIZONTAL) {
                                  // horizontal scrolling is trickier if we want to keep tiles going left to right, then top to bottom.
                                  // we can use availableWidth / availableHeight from BaseScrollPane here, because we've just called drawLayout, so we know they are accurate.
                                  var fullCols:uint = availableWidth/colW<<0;
                                  var rowLength:uint = Math.max(fullCols,Math.ceil(length/rows));
                                  baseCol = _horizontalScrollPosition/colW<<0;
                                  cols = Math.max(fullCols,Math.min(rowLength-baseCol,cols+1));//(horizontalScrollBar.visible ? 1 : -1))); // need to draw an extra two cols for scrolling.
                                  //rowLength = Math.max(cols-(horizontalScrollBar.visible ? -1 : 0),rowLength);
                                  for (row=0; row<rows; row++) {
                                          for (col=0; col<cols; col++) {
                                                  itemIndex = row*rowLength+baseCol+col;
                                                  if (itemIndex >= length) { break; }
                                                  items.push(itemIndex);
                                          }
                                  }
                          } else {
                                  rows++; // need to draw an extra row for scrolling.
                                  baseRow = _verticalScrollPosition/rowH<<0;
                                  var startIndex:uint = Math.floor(baseRow*cols);
                                  var endIndex:uint = Math.min(length,startIndex+rows*cols);
                                  for (i=startIndex; i<endIndex; i++) {
                                          items.push(i);
                                  }
                          }
  
                          // create a dictionary for looking up the new "displayed" items:
                          var itemHash:Dictionary = renderedItems = new Dictionary(true);
                          for each (itemIndex in items) {
                                  itemHash[_dataProvider.getItemAt(itemIndex)] = true;
                          }
  
                          // find cell renderers that are still active, and make those that aren't active available:
                          var itemToRendererHash:Dictionary = new Dictionary(true);
                          while (activeCellRenderers.length > 0) {
                                  renderer = activeCellRenderers.pop();
                                  item = renderer.data;
                                  if (itemHash[item] == null || invalidItems[item] == true) {
                                          availableCellRenderers.push(renderer);
                                  } else {
                                          itemToRendererHash[item] = renderer;
                                          // prevent problems with duplicate objects:
                                          invalidItems[item] = true;
                                  }
                                  list.removeChild(renderer as DisplayObject);
                          }
                          invalidItems = new Dictionary(true);
  
                          i = 0; // count of items placed.
                          // draw cell renderers:
                          for each (itemIndex in items) {
                                  col = i\%cols;
                                  row = i/cols<<0;
  
                                  var reused:Boolean = false;
                                  item = _dataProvider.getItemAt(itemIndex);
                                  if (itemToRendererHash[item] != null) {
                                          // existing renderer for this item we can reuse:
                                          reused = true;
                                          renderer = itemToRendererHash[item];
                                          delete(itemToRendererHash[item]);
                                  } else if (availableCellRenderers.length > 0) {
                                          // recycle an old renderer:
                                          renderer = availableCellRenderers.pop() as ICellRenderer;
                                  } else {
                                          // out of renderers, create a new one:
                                          renderer = getDisplayObjectInstance(getStyleValue("cellRenderer")) as ICellRenderer;
                                          var rendererSprite:Sprite = 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);
                                  activeCellRenderers.push(renderer);
  
                                  renderer.y = rowH*row;
                                  renderer.x = colW*col;
                                  renderer.setSize(columnWidth,rowHeight);
  
                                  var label:String = itemToLabel(item);
                                  
                                  var icon:Object = null;
                                  if (_iconFunction != null) {
                                          icon = _iconFunction(item);
                                  } else if (_iconField != null) {
                                          icon = item [iconField];
                                  }
                                  
                                  var source:Object = null;
                                  if (_sourceFunction != null) {
                                          source = _sourceFunction(item);        
                                  } else if (_sourceField != null) {
                                          source = item [sourceField];
                                  }
  
                                  if (!reused) {
                                          renderer.data = item;
                                  }
                                  
                                  renderer.listData = new @fileData(label,icon,source,this,itemIndex,baseRow+row,baseCol+col) as ListData;
  
                                  renderer.selected = (_selectedIndices.indexOf(itemIndex) != -1);
  
                                  // force an immediate draw (because render event will not be called on the renderer):
                                  if (renderer is UIComponent) {
                                          var rendererUIC:UIComponent = renderer as UIComponent;
                                          rendererUIC.drawNow();
                                  }
                                  i++;
                          }
                  }