舰人   ---      指装备先进的弄潮儿，偶尔有炫耀的成分

联系方式： KingFo     oicuicu@gmail.com

================
已更新团队共享PPT中
================

===============

有点悲剧的是当PPT导入到 Google Docs 中后畸形了许多。。。将就看吧=。=

 全屏可能会好一点

 或者点此处：http://docs.google.com/present/view?id=dcvxfmd9_37fk9bxgfq&interval=10 

这里公布答案:

getDefinitionByName()  它将直接从当前应用程序域(ApplicationDomain)去查询并获取，因此当我们Load，一个swf执行时，会报错。

有时候对于多层次的应用程序域（相当于应用程序域的树，层次>=3）管理起来会非常麻烦。

因此我们需要单独提取出LoaderContext 管理他们，通过LoaderContext的applicationDomain中getDefinition()来管理它们。例如 单例模式。

道理弄懂了，实现起来就是很简单的东西了。

当然，这里随机的方式不做讨论，可以参阅之前本人的 48位线性同余算法的 [原]关于股子系统的优化

完整代码:
 

package  {  
    import flash.utils.getDefinitionByName;  
      
    /**  
     * ...  
     * @author Telds[KingFo]  
     */ 
    public class SampleImage {  
          
        [Embed(source = '../assets/building/image0.png')]public static const BUILDING_0:Class;  
        [Embed(source = '../assets/building/image1.png')]public static const BUILDING_1:Class;  
        [Embed(source = '../assets/building/image2.png')]public static const BUILDING_2:Class;  
        [Embed(source = '../assets/building/image3.png')]public static const BUILDING_3:Class;  
        [Embed(source = '../assets/building/image4.png')]public static const BUILDING_4:Class;  
        [Embed(source = '../assets/building/image5.png')]public static const BUILDING_5:Class;  
        [Embed(source = '../assets/building/image6.png')]public static const BUILDING_6:Class;  
        [Embed(source = '../assets/building/image7.png')]public static const BUILDING_7:Class;  
        [Embed(source = '../assets/building/image8.png')]public static const BUILDING_8:Class;  
        [Embed(source = '../assets/building/image9.png')]public static const BUILDING_9:Class;  
        [Embed(source = '../assets/building/image10.png')]public static const BUILDING_10:Class;  
        [Embed(source = '../assets/building/image11.png')]public static const BUILDING_11:Class;  
        [Embed(source = '../assets/building/image12.png')]public static const BUILDING_12:Class;  
          
        public static function getRandomImageClass():Class {  
            var n:String = "SampleImage_BUILDING_";  
            var i:int = Math.random() * 12;  
            n = n.concat(i);  
            return getDefinitionByName(n) as Class;  
        }  
          
    }  
      
} 

至于如何知道完全限定类名

可以使用以下类进行测试获取，这里值得一提的是我上面的写法是比较特殊例子，至于为什么特殊就留着看客您琢磨了~~~
 

flash.utils.getQualifiedClassName ()  

已完成数据解码和校验~~~~ 不过目前还是体力活~~~

接下来是还原图片。。。。。。哎，周末结束了.............真不知道我下次有时间是什么时候了。。

以下是测试代码，工程截图............. 哦 对了，这个所谓的 1455049.png就是前篇博文：APNG?
中插入图片，我之所以写这段解码器目的其实只是想让IE也能预览APNG而已........哎.....
不知道哪位同学有APNG解码器的代码呢？有的话可以告诉我声哦~~~

public function Main():void {  
            var l:URLLoader = new URLLoader();  
            l.dataFormat = URLLoaderDataFormat.BINARY;  
            l.addEventListener(Event.COMPLETE, handleURLloader);  
            l.load(new URLRequest("../image/1455049.png"));  
            }  
          
        private function handleURLloader(e:Event):void {  
            apngdecoder.decode(e.target.data)  
            trace(apngdecoder.getResult().getTotalFrames())  
            trace(apngdecoder.getResult().getWidth())  
            trace(apngdecoder.getResult().getWidth())  
            trace(apngdecoder.getResult().getBitDepth())  
              
                          
        } 

本人的类:

package  {  
    import flash.utils.ByteArray;  
      
    /**  
     * CRC 32位 校验类  
     * 与JAVA的CRC32类似  
     * 算法参考自 as3corelib http://code.google.com/p/as3corelib/    
     * 的 PNGEncoder.as 中CRC算法部分  
     * @author Telds[KingFo]  
     * @version 0.0.1  
     * @example  
     * var bytes:ByteArray = new ByteArray();  
     * var crc32:CRC32 = new CRC32();  
     * var str:String="kingfo";  
     * bytes.writeUTFBytes(str);  
     * crc32.update(bytes);  
     * trace(crc32);  
     */ 
    public class CRC32 {  
        public static const POLYNOMIAL:uint = 0xEDB88320;  
        /**  
         * 创建获取CRC表  
         * @return  
         */ 
        public static function getCrcTable():Array {  
            /* Make the table for a fast CRC. */ 
            if (!crcTableComputed) {  
                crcTable = new Array(256);  
                var c:uint;  
                for (var i:uint=0; i < 256; i++) {  
                    c = i;  
                    for (var j:uint=0; j < 8; j++) {  
                        c = (c & 1) ? (c >>> 1) ^ POLYNOMIAL : (c >>> 1);  
                    }  
                    crcTable[i] = c;  
                }  
                crcTableComputed = true;  
            }             
            return crcTable;  
        }  
        /**  
         * 构造函数，实例化同时产生CRC表  
         */ 
        public function CRC32() {  
            getCrcTable();  
        }         
        /**  
         * 更新CRC  
         * @param   bytes                   指定更新的字节流  
         * @param   offset                  偏移量，默认从 bytes.position=0 开始  
         * @param   length                  长度,默认为0，即指定更新的字节流的长度          
         */ 
        public function update(bytes:ByteArray, offset:int=0,length:int=0):void {  
            length = length > 0 ? length : bytes.length;  
            var c:uint = ~value;  
            for (var i:int = offset; i < length; i++) {  
                c = crcTable[(c ^ bytes[i]) & 0xFF] ^ (c >>> 8);  
            }  
            value = ~c;  
        }  
        /**  
         * 获取结果  
         * @return  
         */ 
        public function getValue():uint {  
            return value & 0xFFFFFFFF;  
        }  
        /**  
         * 重置结果  
         */ 
        public function reset():void {  
            value = 0x00000000;  
        }  
          
        public function toString():String {  
            var v:uint = getValue();  
            return "0x"+v.toString(16).toUpperCase();  
        }  
          
          
 
        private var value:uint = 0x00000000;          
        /* Table of CRCs of all 8-bit messages. */ 
        private static var crcTable:Array;  
        /* Flag: has the table been computed? Initially false. */ 
        private static var crcTableComputed:Boolean = false;  
          
          
    }  
      
} 

PNGEncoder.as 中CRC 核心代码部分:
 

if (!crcTableComputed) {  
            crcTableComputed = true;  
            crcTable = [];  
            var c:uint;  
            for (var n:uint = 0; n < 256; n++) {  
                c = n;  
                for (var k:uint = 0; k < 8; k++) {  
                    if (c & 1) {  
                        c = uint(uint(0xedb88320) ^   
                            uint(c >>> 1));  
                    } else {  
                        c = uint(c >>> 1);  
                    }  
                }  
                crcTable[n] = c;  
            }  
        }  
/////  
c = 0xffffffff;  
        for (var i:int = 0; i < (e-p); i++) {  
            c = uint(crcTable[  
                (c ^ png.readUnsignedByte()) &   
                uint(0xff)] ^ uint(c >>> 8));  
        }  
        c = uint(c^uint(0xffffffff)); 

Sample Cyclic Redundancy Code implementation
 

/* Table of CRCs of all 8-bit messages. */ 
   unsigned long crc_table[256];  
     
   /* Flag: has the table been computed? Initially false. */ 
   int crc_table_computed = 0;  
     
   /* Make the table for a fast CRC. */ 
   void make_crc_table(void)  
   {  
     unsigned long c;  
     int n, k;  
     
     for (n = 0; n < 256; n++) {  
       c = (unsigned long) n;  
       for (k = 0; k < 8; k++) {  
         if (c & 1)  
           c = 0xedb88320L ^ (c >> 1);  
         else 
           c = c >> 1;  
       }  
       crc_table[n] = c;  
     }  
     crc_table_computed = 1;  
   }  
    
 
   /* Update a running CRC with the bytes buf[0..len-1]--the CRC  
      should be initialized to all 1's, and the transmitted value  
      is the 1's complement of the final running CRC (see the  
      crc() routine below). */ 
     
   unsigned long update_crc(unsigned long crc, unsigned char *buf,  
                            int len)  
   {  
     unsigned long c = crc;  
     int n;  
     
     if (!crc_table_computed)  
       make_crc_table();  
     for (n = 0; n < len; n++) {  
       c = crc_table[(c ^ buf[n]) & 0xff] ^ (c >> 8);  
     }  
     return c;  
   }  
     
   /* Return the CRC of the bytes buf[0..len-1]. */ 
   unsigned long crc(unsigned char *buf, int len)  
   {  
     return update_crc(0xffffffffL, buf, len) ^ 0xffffffffL;  
   }  
 

果然是无法Draw的，在帮助文档已经明确的写了......................................

如何突破呢？ 还是以后直接拿TextField来用？

以此标记，下回，改用AVM1+AVM2混合内容测试

目前方法是猥琐的抽出Loader来用

测试连接：
www.xintend.com/temp/icd/index.html

有兴趣的同学可以去玩下~~ 图片可以拖动~~~~~~~

核心 代码部分:
 

 function handleLoadBtn():void {  
            var s:String = urlInput.text;  
            var ht:String = "<img src='";  
            if (s.length > 0) {  
                ht += s;                                  
                ht += "' ";  
                ht += "id='image'>";  
                tf.htmlText = ht;  
                output.text = ht;  
                output.text += "\n";                  
                output.text += tf.getImageReference("image");  
                var c:DisplayObject = tf.getImageReference("image");  
                ui.addChild(c);  
                output.text += "\n ui.addChild(c);";  
            }  
        } 

本次纠正模型如下(点击图片看大图)：
还是需要等待时间和实践的验证~~~

不过，有些郁闷的是开店需要用到的图片，淘宝发布商品是不支持上传的，于是找了N多家

虽然最终被我找到了几个免费的图片供应站，但是仍然觉得很不爽，毕竟静态图片要表现的内容也算是比较小的。

于是，我本着万愚之精神，开始设想，如果taobao不提供上传，那至少可以提供一个图片的播放器给用户....不过，由于flash player有安全沙箱问题，无法装载外站图片，但不知道类似扒来的图片连接能不能用......或者，干脆用AVM1机制下的一些猥琐方法？？ 没玩过......有谁知道可以告诉我下~~~~，厄，要不HtmlText纯载如图片映射？？？ 哎，不猜测了，这几日测试看看好了~~~

好吧，土人的设想是这么一副图片，主要是供给店主使用的，放在商品介绍上..... 这个成本应该比视频类的滴了吧............这样店主就应该很容易的展示自己的商品了，客户也容易逛到一个店后在一个窗口下所谓的无刷新搜索其他产品和比较产品以及欣赏产品了吧,(这句话我承认有点长了~~就委屈您囧一下吧~~)

好，来图土一土~~~ 超级打算嘛~~~

由于笔记本或多网卡联网机器的原因，所以我们需要判断被系统选择使用的网卡，因此，需要在原文中的判断处获取所选择DNS列表来判断是否正在使用。

不知道还有什么更好的办法，本方法也是一种判断的方式：

以下为完全HTML源码：
(相关API请参考: http://www.xintend.com/Article/QFFrUjDCBWYWzjoBinNT.aspx )

<HTML><HEAD><TITLE>WMI Scripting HTML</TITLE> 
<META http-equiv=Content-Type content="text/html; charset=gb2312"> 
<SCRIPT language=JScript event="OnCompleted(hResult,pErrorObject, pAsyncContext)" for=foo> 
document.forms[0].txtMACAddr.value=unescape(MACAddr);  
document.forms[0].txtIPAddr.value=unescape(IPAddr);  
document.forms[0].txtDNSName.value=unescape(sDNSName);  
 
  </SCRIPT> 
 
<SCRIPT language=JScript event=OnObjectReady(objObject,objAsyncContext) for=foo> 
   if(objObject.IPEnabled != null && objObject.IPEnabled != "undefined" && objObject.IPEnabled == true)  
    {  
    if(objObject.MACAddress != null && objObject.MACAddress != "undefined" && objObject.DNSServerSearchOrder!=null)  
     MACAddr = objObject.MACAddress;  
    if(objObject.IPEnabled && objObject.IPAddress(0) != null && objObject.IPAddress(0) != "undefined" && objObject.DNSServerSearchOrder!=null)  
     IPAddr = objObject.IPAddress(0);  
    if(objObject.DNSHostName != null && objObject.DNSHostName != "undefined")  
     sDNSName = objObject.DNSHostName;  
     }  
  </SCRIPT> 
 
<META content="MSHTML 6.00.2800.1106" name=GENERATOR></HEAD> 
<BODY> 
<OBJECT id=locator classid=CLSID:76A64158-CB41-11D1-8B02-00600806D9B6 VIEWASTEXT></OBJECT> 
<OBJECT id=foo classid=CLSID:75718C9A-F029-11d1-A1AC-00C04FB6C223></OBJECT> 
<SCRIPT language=JScript> 
   var service = locator.ConnectServer();  
   var MACAddr ;  
   var IPAddr ;  
   var DomainAddr;  
   var sDNSName;  
    service.Security_.ImpersonationLevel=3;  
    service.InstancesOfAsync(foo, 'Win32_NetworkAdapterConfiguration');  
   </SCRIPT> 
 
<FORM id="formfoo" name="formbar" action="index.do" method="post"><INPUT value="00-11-11-B4-52-EF" name="txtMACAddr"> <INPUT value="210.42.38.50" name="txtIPAddr"> <INPUT value="zhupan" name="txtDNSName"> </FORM></BODY></HTML> 

addFrameScript(frame:unit,notify:Function):void; 

相信很多人都尝试过以下输出公共方法的函数
 

describeType(); 

所以通过解析可以明显的看出来是类似：
 

addFrameScript(...args):void; 

可以理解成为：
 

addFrameScript(frame:Object, notify:Function):void; 

实际上我的猜测是

//伪码  
function addFrameScript(..args):void{  
    var i:int=0;  
    var frame:Object  
    var notify::Function  
    for(;i<args.length;i+=2){  
       frame=args[i];  
       notify=args[i+1];
        //TODO:  
 }  
 
} 

 用法:
 

addFrameScript("frameLabel",func);  
//或  
addFrameScript(1,func); 

动态注册点显示对象 AS3实现

源码：
 

package  com.xintend.util {  
    import flash.display.DisplayObject;  
    import flash.display.Sprite;  
    import flash.geom.Point;  
    import flash.utils.Proxy;  
    import flash.utils.flash_proxy;  
 
      
    /**  
    * [AS3]DynamicRegistrationProxy  
    * 动态注册点代理   引用请保留此处信息及参考信息  
    * @author telds[kingfo] www.xintend.com   
    *   
    *   
    * 一级参考:  
    *   作者： Darronschall        [ActionScript 2]  
    *   站点: http://www.darronschall.com/weblog/archives/000054.cfm  
    *   
    * 二级参考:  
    *   作者:     Robert Penner       [ActionScript 1]  
    *   站点: www.robertpenner.com      
    *   
    */ 
    public dynamic class DynamicRegistrationProxy extends Proxy {         
          
        public function DynamicRegistrationProxy(source:DisplayObject=null):void {  
            _displayObject = source || new Sprite();  
        }  
          
        override flash_proxy function callProperty(methodName:*, ... args):*  {  
            var res:*;  
            var a:Point;  
            var b:Point;  
            var method:String = methodName.toString();  
            var property:String;  
            switch (method) {  
                case 'setRegistrationByStage':  
                    a = _displayObject.globalToLocal(new Point(args[0], args[1]));                    
                    _stageRegX = args[0];  
                    _stageRegY = args[1];         
                    _regX = a.x;  
                    _regY = a.y;  
                break;  
                case 'setRegistrationBySelf':  
                    a = _displayObject.localToGlobal(new Point(args[0], args[1]));                    
                    _regX = args[0];  
                    _regY = args[1];          
                    _stageRegX = a.x;  
                    _stageRegY = a.y;  
                break;  
                case 'setPropRel':  
                    a = _displayObject.parent.globalToLocal(_displayObject.localToGlobal(new Point(_regX, _regY)));  
                    property = args[0].toString();  
                    _displayObject[property] = args[1];           
                    b = _displayObject.parent.globalToLocal(_displayObject.localToGlobal(new Point(_regX, _regY)));       
                    _displayObject.x -= b.x - a.x;  
                    _displayObject.y -= b.y - a.y;  
                break;                
                default:  
                    res = _displayObject[method].apply(_displayObject, args);  
                break;  
            }  
            return res;  
        }  
          
        override flash_proxy function getProperty(name:*):* {  
            var res:*;  
            var property:String = name.toString();  
            switch (property) {  
                case 'regX':  
                    res = _regX;  
                break;  
                case 'regY':  
                    res = _regY;  
                break;  
                case 'stageRegX':  
                    res = _stageRegX;  
                break;  
                case 'stageRegY':  
                    res = _stageRegY;  
                break;  
                case 'x2':  
                    res = _x2;  
                break;  
                case 'y2':  
                    res = _y2;  
                break;  
                case 'scaleX2':  
                    res = _displayObject.scaleX;  
                break;  
                case 'scaleY2':  
                    res = _displayObject.scaleY;  
                break;  
                case 'rotation2':  
                    res = _displayObject.rotation  
                break;  
                case 'source':  
                    res = _displayObject;  
                break;  
                default:  
                    res = _displayObject[property];  
                break;  
            }  
            return res;  
        }  
 
        override flash_proxy function setProperty(name:*, value:*):void {  
            var property:String = name.toString();            
            switch (property) {  
                case 'regX':  
                    _regX = value;  
                break;  
                case 'regY':  
                    _regY = value;  
                break;  
                case 'stageRegX':  
                    _stageRegX = value;  
                break;  
                case 'stageRegY':  
                    _stageRegY = value;  
                break;  
                case 'x2':  
                    _x2 += value - _displayObject.x;  
                break;  
                case 'y2':  
                    _y2 += value - _displayObject.y;  
                break;  
                case 'scaleX2':  
                    flash_proxy::callProperty('setPropRel',"scaleX", value);  
                break;  
                case 'scaleY2':  
                    flash_proxy::callProperty('setPropRel',"scaleY", value);  
                break;  
                case 'rotation2':  
                    flash_proxy::callProperty('setPropRel',"rotation", value);  
                break;  
                default:  
                    _displayObject[property] = value;  
                    break;  
            }  
        }  
 
          
          
        private var  _displayObject:DisplayObject;  
        private var _regX:Number = 0;  
        private var _regY:Number = 0;  
        private var _stageRegX:Number = 0;  
        private var _stageRegY:Number = 0;  
        private var _x2:Number = 0;  
        private var _y2:Number = 0;  
    }  
      
} 

示例源码：
 

package {  
      
    import com.xintend.util.DynamicRegistrationProxy;  
    import flash.display.Bitmap;  
    import flash.display.Sprite;  
    import flash.events.MouseEvent;  
    import flash.geom.Point;  
      
    public class Main extends Sprite    {  
          
        private var a:DynamicRegistrationProxy;  
        private var t:Sprite = new Sprite();  
        private var c:CrossHairs = new CrossHairs();  
        [Embed(source = '../bin/123.jpg')]private var imge:Class;  
        private var b:Bitmap  
        public function Main():void {  
              
            b=new imge() as Bitmap  
              
            //t.graphics.beginFill(0xFF0000);  
            //t.graphics.drawRect(0, 0, 80, 40);  
            //t.graphics.endFill();  
              
            //t.buttonMode = true;  
            //t.useHandCursor = true;  
              
            t.addChild(b);  
            c.x = t.x = stage.stageWidth / 2- t.width/2;  
            c.y = t.y = stage.stageHeight / 2 - t.height/2;  
              
              
            t.addEventListener(MouseEvent.MOUSE_DOWN, handleMOUSE);  
            t.addEventListener(MouseEvent.MOUSE_OUT, handleMOUSE);  
            t.addEventListener(MouseEvent.MOUSE_WHEEL, handleMOUSE);  
              
            a = new DynamicRegistrationProxy(t);  
              
            addChild(t);  
            addChild(c);  
        }  
          
        private  function handleMOUSE(event:MouseEvent):void {  
            switch(event.type) {  
                case MouseEvent.MOUSE_DOWN:  
                    a.setRegistrationByStage(mouseX, mouseY);  
                    //trace(t.globalToLocal(new Point(mouseX,0)).x,t.globalToLocal(new Point(0,mouseY)).y);  
                    c.x = mouseX;  
                    c.y = mouseY;  
                    removeEventListener(MouseEvent.MOUSE_DOWN, handleMOUSE);  
                    addEventListener(MouseEvent.MOUSE_MOVE, handleMOUSE);  
                    addEventListener(MouseEvent.MOUSE_UP, handleMOUSE);  
                break;  
                case MouseEvent.MOUSE_MOVE:  
                    //trace(t.mouseX - a.regX, t.mouseY - a.regY);  
                    a.rotation2 += 5;  
                    //a.scaleXByRefer += 5;  
                break;  
                case MouseEvent.MOUSE_UP:     
                    addEventListener(MouseEvent.MOUSE_DOWN, handleMOUSE);  
                    removeEventListener(MouseEvent.MOUSE_MOVE, handleMOUSE);  
                break;  
                case MouseEvent.MOUSE_WHEEL:      
                    removeEventListener(MouseEvent.MOUSE_MOVE, handleMOUSE);  
                    c.x = mouseX;  
                    c.y = mouseY  
                    a.setRegistrationByStage(mouseX, mouseY);  
                    a.scaleX2 += event.delta * 0.1;  
                    a.scaleY2 += event.delta * 0.1;  
                break;  
                default:  
                    addEventListener(MouseEvent.MOUSE_DOWN, handleMOUSE);  
                    removeEventListener(MouseEvent.MOUSE_MOVE, handleMOUSE);  
            }  
        }  
    }  
}  
import flash.display.Shape;  
 
class CrossHairs extends Shape {  
    public function CrossHairs() {  
        graphics.lineStyle(2,0xFF0000);  
        graphics.moveTo( -10, 0);  
        graphics.lineTo( 10, 0);  
        graphics.moveTo( 0, -10);  
        graphics.lineTo( 0, 10);  
    }  
} 

P.S：这个应用类我就改了下，现实中我是将这个类给做成了Proxy来代替现有的Display以及子类。

package com.xintend.util {  
    import flash.display.DisplayObject;  
    import flash.display.Sprite;  
    import flash.geom.Point;  
      
    /**  
    * [AS3]DynamicRegistrationDisplayObject  
    * 动态注册点   
    * @author telds[kingfo] www.xintend.com    
    *   
    * 一级参考:  
    *   作者： Darronschall        [ActionScript 2]  
    *   站点: http://www.darronschall.com/weblog/archives/000054.cfm  
    *   
    * 二级参考:  
    *   作者:     Robert Penner       [ActionScript 1]  
    *   站点: www.robertpenner.com      
      
    */ 
    public class DynamicRegistrationDisplayObject{  
        public function get displayObject():DisplayObject { return _displayObject; }  
          
        public function get depth():Number { return _depth; }  
        public function set depth(value:Number):void {  
            _depth = value;  
        }  
          
        public function get label():String { return _label; }         
        public function set label(value:String):void {  
            _label = value;  
        }  
          
          
        public function get stageRegX():Number { return _stageRegX; }         
        public function get stageRegY():Number { return _stageRegY; }         
          
          
        public function get centerX():Number { return _displayObject.x + _displayObject.width / 2; }          
        public function set centerX(value:Number):void {  
            _displayObject.x = value - _displayObject.width / 2;  
        }  
          
          
        public function get centerY():Number { return _displayObject.y + _displayObject.height / 2; }         
        public function set centerY(value:Number):void {  
            _displayObject.y = value - _displayObject.height / 2;  
        }             
          
        public function get regX():Number { return _regX; }   
        public function get regY():Number { return _regY; }       
          
          
          
        public function DynamicRegistrationDisplayObject():void {  
            initializtion();  
        }  
          
        public function setRegistrationByStage(stageX:Number, stageY:Number):void {  
            _stageRegX = stageX;  
            _stageRegY = stageY;  
            var p:Point = _displayObject.globalToLocal(new Point(stageX,stageY));  
            _regX = p.x;  
            _regY = p.y;  
        }  
          
        public function setRegistrationBySelf(selfX:Number, selfY:Number):void {  
            var p:Point = _displayObject.localToGlobal(new Point(selfX,selfY));  
            _stageRegX = p.x;  
            _stageRegY = p.y;             
            _regX = selfX;  
            _regY = selfY;  
        }  
          
        public function get rotationByRefer():Number { return _displayObject.rotation   }  
        public function set rotationByRefer(value:Number):void {                                      
            setPropRel("rotation", value);  
        }  
          
        public function get scaleXByRefer():Number { return _displayObject.scaleX   }  
        public function set scaleXByRefer(value:Number):void {                                    
            setPropRel("scaleX", value);  
        }  
          
        public function get scaleYByRefer():Number { return _displayObject.scaleY   }  
        public function set scaleYByRefer(value:Number):void {                                    
            setPropRel("scaleY", value);  
        }  
          
          
          
          
        public function initializtion(displayObject:DisplayObject=null):void {  
            //throw new Error("AbstractTile is an Abstract Class");  
            _displayObject = displayObject || new Sprite();  
        }  
          
        protected function setPropRel(property:String, value:Number):void {  
            var p:Point = _displayObject.parent.globalToLocal(_displayObject.localToGlobal(new Point(_regX, _regY)));  
            _displayObject[property] = value;             
            var pp:Point = _displayObject.parent.globalToLocal(_displayObject.localToGlobal(new Point(_regX, _regY)));        
            _displayObject.x -= pp.x - p.x;  
            _displayObject.y -= pp.y - p.y;  
        }  
          
        private var _depth:Number;  
        private var _label:String;  
        private var _regX:Number = 0;  
        private var _regY:Number = 0;  
        private var _stageRegX:Number = 0;  
        private var _stageRegY:Number = 0;  
        private var  _displayObject:DisplayObject;  
    }  
      
} 

应用代码:

package {  
    import com.xintend.util.DynamicRegistrationDisplayObject;  
    import flash.display.Sprite;  
    import flash.events.MouseEvent;  
    import flash.geom.Point;  
    /**  
    * [AS3]DynamicRegistrationDisplayObjectTest  
    * 动态注册点测试  
    * @author telds[kingfo] www.xintend.com   
    */ 
    public class DynamicRegistrationDisplayObjectTest extends Sprite    {  
          
        private var a:DynamicRegistrationDisplayObject= new DynamicRegistrationDisplayObject();  
        private var t:Sprite = new Sprite();  
        private var c:CrossHairs = new CrossHairs();  
          
        public function DynamicRegistrationDisplayObjectTest():void {             
            t.graphics.beginFill(0xFF0000);  
            t.graphics.drawRect(0, 0, 80, 40);  
            t.graphics.endFill();  
            c.x = t.x = stage.stageWidth / 2- t.width/2;  
            c.y = t.y = stage.stageHeight / 2 - t.height/2;  
            t.buttonMode = true;  
            t.useHandCursor = true;  
              
            t.addEventListener(MouseEvent.MOUSE_DOWN, handleMOUSE);  
            t.addEventListener(MouseEvent.MOUSE_OUT, handleMOUSE);  
              
            a.initializtion(t);  
              
            addChild(t);  
            addChild(c);  
        }  
          
        private  function handleMOUSE(event:MouseEvent):void {  
            switch(event.type) {  
                case MouseEvent.MOUSE_DOWN:  
                    a.setRegistrationByStage(mouseX, mouseY);  
                    trace(a.regX,a.regY);  
                    trace(a.stageRegX, a.stageRegY);  
                    trace(t.globalToLocal(new Point(mouseX,0)).x,t.globalToLocal(new Point(0,mouseY)).y);  
                    c.x = mouseX;  
                    c.y = mouseY  
                    removeEventListener(MouseEvent.MOUSE_DOWN, handleMOUSE);  
                    addEventListener(MouseEvent.MOUSE_MOVE, handleMOUSE);  
                    addEventListener(MouseEvent.MOUSE_UP, handleMOUSE);  
                break;  
                case MouseEvent.MOUSE_MOVE:  
                    trace(t.mouseX - a.regX, t.mouseY - a.regY);  
                    a.rotationByRefer += 5;  
                    //a.scaleXByRefer += 5;  
                break;  
                case MouseEvent.MOUSE_UP:     
                    addEventListener(MouseEvent.MOUSE_DOWN, handleMOUSE);  
                    removeEventListener(MouseEvent.MOUSE_MOVE, handleMOUSE);  
                break;  
                default:  
                    addEventListener(MouseEvent.MOUSE_DOWN, handleMOUSE);  
                    removeEventListener(MouseEvent.MOUSE_MOVE, handleMOUSE);  
            }  
        }  
    }  
}  
import flash.display.Shape;  
 
class CrossHairs extends Shape {  
    public function CrossHairs() {  
        graphics.lineStyle(1,0);  
        graphics.moveTo( -10, 0);  
        graphics.lineTo( 10, 0);  
        graphics.moveTo( 0, -10);  
        graphics.lineTo( 0, 10);  
    }  
} 

SWF: 

点击下载此文件

这里所说的开发模式是开发前所需要思考的问题。

这里就不长篇大论了，依次罗列和解说如下：

三种开发模式：

A.从底至上

B.从上往下

C.各路铺开

A.从底至上是本人认为最为保守，和最为有效的开发模式，原因在于，你经过对即将展开的项目中，挑选出自己认为最喜欢和最希望能够实现的功能，包含了可行性测试和简单的方法实现。精髓就在于“足够简单的实现”。这就决定了，开发者可以立即着手开始自己最关心的部分实现。

B.由上往下，这可能会和设计模式结合在一起，因为从上而下，精髓在于“足够全面的考虑”，当然这里所说的足够全面是当前情况下必要考虑。而和设计模式结合的原因就是减少改动的开销，和已有资源的重复利用。一般来说这种模式需要依靠在这个领域有足够经验的人，至于一般的开发者如何获取如此的经验就不在本文中考虑了。

C.各路铺开这种模式之所以独立于前两者的原因在于，这个模式下不仅仅是一个人的模式。这意味着这个项目将是跨领域或是跨行业的，需要在展开前需要收集各种信息，通过验证的手段进行筛选然后全局应用。也许在很多情况下这种方式是必要的和极限的。本人是不太推荐这个模式，因为这意味着最大成本的投入。当然目前互联网商业上的项目应用倒是比较接近这个。

小结：

个人的兴趣项目可以考虑模式A，而想让自己成为架构师等级的则可以从B开始锻炼，而C则一般在互联网商业团队中已经类似，所以，这就需要有成熟的B专家，和优秀的A的成员们。

-----------------------------------------------------------------------------------------------------------------------------

章1：混沌之元
节1：泰格斯

泰格斯一直不知道自己父母是谁，从小也没有人抚养自己，谁也不知道他的过去，自从泰格斯发现自己晕倒在沼泽旁，这就是他的首要的问题。

泰格斯也许失意了，这让他觉得是件不可思议的事，但事实如此。无论如何回忆自己的过去，最终始终都是空白。但回忆别的倒是可以立即找到答案。

“该死的，莫非我患了选择性失意？！！TMD，只有在小说里出现的事情竟然发生了！！”泰达斯懊恼道。

庆幸的是泰格斯知道自己的名字和住址，以及出生时间，因为他从自己的上衣袋里发现了一张卡片，准确的说是张印有某个标记的身份证，上面写着“世纪联邦政府公民身份证”字样。在姓名一栏内写着“泰格斯”，在住址一栏写着“湖枫境月州，黄昏湖49307号，锦座18楼601室”，而出生一栏则写着世纪元年0029.07.07。而在最后一栏有着行128位的数字以及对应的条形码，在卡片的背面，除了像正面的“世纪联邦政府”一样的标记外，还印有一个光芒四射的太阳标记，除了在一旁小字外没任何关于此标记的解释，那行小字写着“宗教派别”。

泰格斯冷静下来后，回忆起自己是个魔法师，但不幸的选择性失意让他无法回忆起这些技能是谁教他的。不过这些问题在这个时候并不是最重要的。

最重要的是解决当前的问题：自己绕这块大地行走了那么长时间，没有发现任何人的踪迹。四处都是古怪的绿色和深紫色的类苔藓的东西，而且在他们之上长出了浅棕色的枝干，而且如果停下来观察，可以发现他们生长速度非常快，像某种攀爬植物，沿着地形向前伸展，遇到同类的枝干，较大的枝干会立刻折断较小的枝干继续向前，而折断的较小枝干则会在断裂的地方流出深红色，浓稠而异味的液体，但很快就会愈合，长出比原先更小的枝干越过较触的枝干继续延伸。

这样的环境不止一次让泰格斯犯恶心，而且十分害怕，因为第一次见到这个状况的时候，泰格斯使用了燃烧之手的魔法，本想烧毁在他面前的这些恶心的东西，但没想到，在烧毁后，竟然从焦黑的枝干管中涌出了大量的白色球体，向他扑来，并粘住他的全身，虽然对拥有法术屏障的泰格斯来说并什么多大伤害，但这些急速聚集的白色小球以数以万计的数量向他堆叠过去。好在泰格斯使用了冰障术，冻住了向他扑来的白色小球，并使用了两次瞬闪术离开了那个地方。

(待续)2008-07-03 23:56:21

小规模实践心得

作者:KingFo   撰写日期:2008-6-30

“Scrum，源自英式橄榄球，团队成员在商定好战略后，按照预定章法向前冲。

在软件开发模型中，这个词代表了敏捷开发的一种。它主要强调的是重新开始迭代的过程，而不是企图补救问题，诸如某公司的产品的本身就是建立在客户的即使反馈上，这意味着在开发过程中需求总是不断的变化和交错的。”

一个典型的例子是，某公司接到一个项目，在这项目开始前谁都无法给出该项目具体的最终形态和功能需求，可能仅仅只知道该项目应该成为什么样子，或者应该向什么方向发展。在项目展开阶段过程中，无论创意、策划、研发都需要通过各种尝试性的错误，才能正确定位。这就好比是英式橄榄球中，除了明确知道最终目标是什么，谁都不知道过程中会发生什么，这就需要各队员间的高度配合，和高度自由的密切合作，以及拿到球就往前冲。

通常的Scrum开发流程一般以30天或更短为一个阶段，由于我们Adobe RIA技术团队具备相对其他开发组的人力及人员涉及面优势，故将迭代周期制定为一周，在这一周内我们所需要做的是

1.      尽量在这周内完成已定目标。

2.      每天通过昨天的目标是否完成、目标是否遇到障碍、今日如何开始的三个问题进行每日15分钟的例会，这些例会都是在上班开始后15分钟内举行。

3.      在周一召开的是未来一周内所需要的目标评估制定，和明确到每日的必完成事项。

4.      在周六召开的是这一整周下来的问题性团队解答，以及产品的回顾和评审。

下面将详细阐述整个周期从开始到结束，以及再开始的过程，我们可以把这样的周期看成为“开始->结束->再开始”的过程.

在开始的详细叙述之前，需要强调的几个关键词和解释按序号罗列如下：

1.      产品负责人(Product Owner)

一般是指由产品经理指派，或产品所有者指派的，负责跟踪和提出产品相关需求的人员，人数一般为1-2名。

2.      Scrum管理员(Scrum Master)

一般是指了解和熟悉Scrum过程，或者愿意出面担当整个项目负责人，以及向产品负责人以及团队之间解释和帮助理解Scrum的利益，以获取整体的帮助和支持。他主要负责的是已定例会的及时召开，以及产品项目整体跟踪。一般指定1名。

3.      待办事项(Backlog)

就是对已知事项，通过三要素(重要性、优先级、要求目标)进行罗列的事项列表。以一项一条列出。

4.      已知产品事项(Product Backlog)

由产品负责人提出的产品上大致的功能性和非功能性的需求列表，按客户需求以重要性和优先级罗列的大致事项。这是给出方向性的第一步。

5.      选定产品事项(Selected Backlog)

这是由产品负责人和项目团队间，通过对已知产品事项(Product Backlog)及有效沟通，将最可能完成和相对成本较低的事项按次序罗列的表格。

6.      迭代冲刺期事项(Sprint Backlog)

这是仅仅由项目团队内部，自我选择和自主担任的事项列表，以确保在已制定的迭代期时间内能够完成的事项，按预计完成日期顺序排列的表格。

7.      障碍和问题事项(Obstacle Backlog)

这是由项目团队内部，通过策划，创意以及研发中失败以及在迭代期内暂时无法完成事项，按时间顺序罗列的表格。

关于开始：

首先，我们要做的就是关于产品的信息收集，这个时候可称为全员通报大会，主要是召集被选定的团队人员以及产品负责人(Product Owner)进行本次项目通报，收集尽可能多的信息。在这期间，除了明确产品的大致方向外，有必要向相关人员解释他们所在整个项目中的相应角色及作用。另外需要明确的是在整个周期过程中的例会次数和时间，以及指定出明确的集体交流场所。通过相关描述将产品的方向性内容罗列成为已知产品事项(Product Backlog)。

其次，由团队和产品负责人之间，相互沟通，以让彼此明确每个产品事项的重要性和优先级(即所谓的紧急性)，团队沟通的明确目标是将最重要的和最紧急的事项，通过工作量/工作成本一一罗列出，并让产品负责人明白哪些可以细分工作，哪些是可以更快完成，哪些是需要具备某些资源后才能开始。并按工作量或工作成本较低的几项纳入到选定产品事项(Selected Backlog)中，并罗列成表格。

再次，由团队内部，通过已有人力物力，从选定产品事项(Selected Backlog)中选出相关事项最佳负责人选。然后各相关事项负责人可以按自己的能力将事项再分为自己最小时间能达成的事项，这是最关键和最重要的部分。通过对该事项的工作量，工作时间，以及完成日期的确定，这时，迭代冲刺期事项(Sprint Backlog)就完成了。

接下来，就是冲刺期间的最小单位团队间的每日例会，依次按三个问题提问:

1.      昨天的目标是否完成？

如果已完成，则会后通知与此相关的责任人。且直接回答第三问。

未完成则讨论第二问。

2.      目标遇到什么困难和障碍？

将困难的特征描述，以获得团队内部其他人员的提示，以便于更好的进行。

如果该困难需要更多的资源支持，可尝试性的将问题拆分为若干子项。

如果该困难需要花费更多时间完成，则在预期周期内可以考虑选择，周期以外的，按紧急程度会后向产品负责人提出请求。并将该问题按发生事件和所在周期罗列入障碍和问题事项(Obstacle Backlog)中。

3.      今天如何开始？

这主要描述的是，障碍或者接下来要解决的事项如何开始，完成后向谁提交等等问题，以及可能在开发中涉及到的遗留问题。诸如，前项未完成，牵连到当前的几项，依次按障碍和问题事项(Obstacle Backlog)的要求罗列入该表中。如果当前迭代冲刺期事项(Sprint Backlog)在上述事项中已空，则再次从选定产品事项(Selected Backlog)选择自己相应能够完成的或者感兴趣能完成的事项，添加到当前迭代冲刺期事项(Sprint Backlog)中。

       看上去可能整个敏捷体系比较复杂，其实，整体运行起来抓住以下几个关键词就相对来说会更容易些，当然，如果只是团队中的一员，这些完全都不用考虑，只需要知道直接感兴趣和能够最快完成的事项以及如何高效完成就可以了。

       整个体系个关键词就是

a)        Backlog       

---          罗列尽可能多的事项

b)        Packets       

---          将Backlog单元分配及相关任务打包指派

c)        Changes           

---               将变动反映到每个Packets中去

d)        Problems     

---          Changes产生的难题都必须具备对应的解决方案和解决链

e)        Issue            

---          从Backlog到Packets指派过程中应该落实的事宜

f)         Solutions      

---          针对Problems或Issue解决方案及产生的Changes

g)        Risks                 

---               针对时间、需求、竞争力、质量、可用资源、产品远景的风险评估

当然，本人也是仅仅是该方式的新手级人物，主要是感觉这样的思想很方式很适合像我们这样Adobe RIA技术的团队。

以以下网络摘录的心得作为本稿的结束：

“1.有商业价值的东西才是企业的目的。

2.团队有权限自行设定交付期限。

3.交付可以使用的软件是最为重要的目标。

4.预先建模和需求采集阶段则要求尽量简单。

5.需求采集并不是在项目早期便结束，而是会在项目开始后很长时间内一直进行的过程。

6.敏捷开发先交付最有用的部分。

7.敏捷注重的是反馈,反馈是双向的。你可以知道增量版本功能是否符合要求，而客户则可以知道你现在在干什么。

8.最好的构架、需求和设计出自于自组织的团队。

9.目标是明确的（不排除有些客户目标也不明确），但是具体怎么做，开始时是没有想法的。

10.敏捷强调的是自组织团队，发挥人的能动性，以动力代替压力，让人有绝对自由的错觉。

11.敏捷不是许多人独立负责开发项目的各个部分，而是大家联合起来，作为一个团队来开发某个部分。”

相关参考：

《Scrum And Xp From The Trenches --- How we do Scrum》

---Henrik Kniberg

《Microsoft .NET 技術代言人專欄：敏捷的軟體開發流程》

              ---作者：林耀珍              2003 年 11 月

《What is Scrum?》

              ---http://www.controlchaos.com/about/

《Scrum Checklists》

              ---http://www.sprint-it.com/scrum-checklists

//系统结构伪码  
Dice implements IDice;  
RandomSystem implements IRandomSystem  
Random48 extends RandomSystem;  
 
interface IRandomSystem {  
    function random(min:Number, max:Number):Number;  
    function randomByRound(min:Number, max:Number,round:int):Array;  
}  
 
interface IDice  {  
    function get sided():int;  
    function roll(round:int, randomSystem:IRandomSystem):DiceArrayList;  
    function toString():String   
}  
 
class DiceArrayList extends com.xintend.as3.dnd.core.ArrayCollection {         
    public function DiceArrayList(data:Array ) {              
    }  
          
    public function get average():int {     }  
    public function get max():int {     }  
    public function get min():int {     }  
    public function get sum():int {     }  
          
    protected function verifyInt():void {}  
}  
         

（测试类）：
 

package {  
      
    import com.xintend.as3.dnd.base.dice.Dice;  
    import com.xintend.as3.dnd.util.Random48;  
    import com.xintend.as3.dnd.util.RandomSystem;  
    import flash.display.Sprite;  
      
    public class Main extends Sprite    {  
        public function Main(){           
            var d1:Dice = new Dice(4);  
            trace(d1.roll(100,new Random48()))  
            trace(d1.roll(100,new RandomSystem()))  
        }  
    }  
} 

测试图(结构在output窗口)：


再次感谢hexagonstar.com开源的DiceClass中的48位线性同余算法