Actionscript 3 禁用spark datagrid中的几行

在spark datagrid中有没有一种方法可以通过编程禁用某些行，在flex 3中，可以使用函数mouseeventtotItemRenderer以这种方式完成：

override protected function mouseEventToItemRenderer (
            event: MouseEvent): IListItemRenderer {
    var listItem: IListItemRenderer;// = super.mouseEventToItemRenderer(event);
    if (_disableFlag) 
    {
        if (listItem) 
        {
            if (listItem.data) 
            {
                if (disabledRow(listItem.data)) 
                {
                    return null;
                }
            }
        }
    }
    return listItem;
}

---

然后我实现disabledRow函数，根据某些条件返回true或false，该条件将指定是否渲染所选项目。spark datagrid中有没有同样的方法？

我认为spark datagrid支持gridrollover事件。这样我们就可以得到

我想这可能适合你

---

如需进一步参考，请参阅

Ok，以下是我的做法

第一步

我创建了SelectionIndicator、HoverIndicator和CaretIndicator类，就像我们在datagrid皮肤中发现的皮肤部分一样，因此皮肤部分CaretIndicator：

<!--- @private -->        
<fx:Component id="caretIndicator">
    <s:Rect implements="spark.components.gridClasses.IGridVisualElement">
        <fx:Script>
            <![CDATA[
                import spark.components.DataGrid;
                import spark.components.Grid;

                /**
                 * @private
                 */
                public function prepareGridVisualElement(grid:Grid, rowIndex:int, columnIndex:int):void
                {
                    const dataGrid:DataGrid = grid.dataGrid;
                    if (!dataGrid)
                        return;

                    const color:uint = dataGrid.getStyle("caretColor");
                    caretIndicatorFill.color = color;
                }
            ]]>
        </fx:Script>

        <s:stroke>
            <!--- @private -->
            <s:SolidColorStroke id="caretIndicatorFill" color="0x0167FF" weight="1"/>
        </s:stroke>
   </s:Rect>
</fx:Component>

SelectionIndicator和HoverIndicator也一样，只是不要忘记使用SolidColor而不是solidColorStroke，使用属性fill或Rect而不是属性stroke

第二步

在个性化数据网格中，我为事件gridClick、gridRollOver和gridMouseDown添加了事件监听器：

this.addEventListener(GridEvent.GRID_CLICK, gridClickHandler);
this.addEventListener(GridEvent.GRID_ROLL_OVER, gridEventHandler);
this.addEventListener(GridEvent.GRID_MOUSE_DOWN, mouse_down_handler);

以下是事件侦听器：

protected function mouse_down_handler(event:GridEvent):void
{
    if (_disableFlag)
    {
        if (event.item)
        {
            if (disabledRow(event.item))
            {
                event.grid.caretIndicator = null;
                event.grid.selectionIndicator = null;
            }
        }
    }
}

protected function gridClickHandler(event:GridEvent):void
{
    if (_disableFlag)
    {
        if (event.item)
        {
            if (!disabledRow(event.item))
            {
                event.grid.selectionIndicator = new ClassFactory(SelectionIndicator);
                event.grid.caretIndicator = new ClassFactory(CaretIndicator);
            }
        }
    }
}

protected function gridEventHandler(event:GridEvent):void
{
    if (_disableFlag)
    {
        if (event.item)
        {
            if(disabledRow(event.item))
            {   
                event.grid.hoverIndicator = null;
            }
            else
            {
                event.grid.hoverIndicator = new ClassFactory(HoverIndicator);
            }
        }
    }
}

您可能已经猜到_disableFlag和disabledRow分别是一个布尔值和一个函数。现在，最后一步是最简单的：

第三步

使用个性化数据网格时，如果要禁用列，请将_disableFlag设置为true，并实现disabledRow，如果满足条件，则返回true，否则返回false

<custom:NinjaGrid id="ninja"
                 _disableFlag=true
                  creationComplete="ninja_trainingCompleteHandler(event)"/>

此解决方案不适用于多行选择模式，我找到了另一种适用于多行选择模式的解决方案

---

第二种解决方案 在这个解决方案中，我只使用HoverIndicator组件，滚动事件的事件监听器将保持不变。我不再使用click事件的事件监听器，在mouse\u down\u handler函数中，我现在有以下代码：

protected function mouse_down_handler(event:GridEvent):void
{
    if(_disableFlag)
    {
        if (event.item)
        {
            if (!disabledRow(event.item))
            {
                if (!event.ctrlKey)
                {
                    tempItem = event.item;
                    tempSelecteditems = new Vector.<Object>();
                    tempSelecteditems.push(tempItem);
                }
                else
                {
                    if (tempSelecteditems.indexOf(event.item) < 0)
                    {
                        tempSelecteditems.push(event.item);
                    }
                    else
                    {
                        tempSelecteditems[tempSelecteditems.indexOf(event.item)] = null;
                    }
                }

            } 
            else
            {
                if (!event.ctrlKey)
                {
                    selectedItem = tempItem;
                    tempSelecteditems = new Vector.<Object>();
                } 
                else
                {
                    if (tempSelecteditems.length)
                    {
                        selectedItems = tempSelecteditems;
                    }
                    else
                    {
                        selectedItem = tempItem;
                    }
                }
            }
        }
    }
}

protected function mouse\u down\u处理程序（事件：GridEvent）：void
{
如果（_disableFlag）
{
如果（事件项）
{
如果（！disabledRow（事件项））
{
如果（！event.ctrlKey）
{
tempItem=event.item；
tempSelecteditems=新向量。（）；
tempSelecteditems.push（tempItem）；
}
其他的
{
if（tempSelecteditems.indexOf（event.item）<0）
{
tempSelecteditems.push（事件项）；
}
其他的
{
tempSelecteditems[tempSelecteditems.indexOf（event.item）]=null；
}
}
} 
其他的
{
如果（！event.ctrlKey）
{
选择editem=tempItem；
tempSelecteditems=新向量。（）；
} 
其他的
{
如果（tempSelecteditems.length）
{
selectedItems=临时selectedItems；
}
其他的
{
选择editem=tempItem；
}
}
}
}
}
}

protected function ninja_trainingCompleteHandler(event:FlexEvent):void
{
    ninja.disabledRow = beNinja;
}
private function beNinja(ninja:Object):Boolean
{
    if (ninja.knowHowToWalkOnWater == true)
        return true;
    return false;
}

protected function mouse_down_handler(event:GridEvent):void
{
    if(_disableFlag)
    {
        if (event.item)
        {
            if (!disabledRow(event.item))
            {
                if (!event.ctrlKey)
                {
                    tempItem = event.item;
                    tempSelecteditems = new Vector.<Object>();
                    tempSelecteditems.push(tempItem);
                }
                else
                {
                    if (tempSelecteditems.indexOf(event.item) < 0)
                    {
                        tempSelecteditems.push(event.item);
                    }
                    else
                    {
                        tempSelecteditems[tempSelecteditems.indexOf(event.item)] = null;
                    }
                }

            } 
            else
            {
                if (!event.ctrlKey)
                {
                    selectedItem = tempItem;
                    tempSelecteditems = new Vector.<Object>();
                } 
                else
                {
                    if (tempSelecteditems.length)
                    {
                        selectedItems = tempSelecteditems;
                    }
                    else
                    {
                        selectedItem = tempItem;
                    }
                }
            }
        }
    }
}