Changeset 7124

Timestamp:

02/25/08 18:27:46 (5 years ago)

Author:

frsyuki

Message:

public interface impl. 2

Location:

lang/actionscript/FxTerm/trunk

Files:

• FxTerm.as (modified) (20 diffs)
• FxTermTest.mxml (modified) (1 diff)
• Telnet.as (moved) (moved from lang/actionscript/FxTerm/trunk/FxTelnet.as) (1 diff)
• Terminal.as (modified) (4 diffs)
• TerminalEvent.as (deleted)

lang/actionscript/FxTerm/trunk/FxTerm.as

@@ -15 +15 @@
 import flash.utils.IDataOutput;
 
-public class FxTerm extends Sprite implements IDataOutput {
-
-        private var telnetClient:FxTelnet;
+public class FxTerm extends Sprite implements IDataOutput
+{
 
         private var screen:Array;  // Array of Array of TextCell
@@ -41 +40 @@
         private var drawBuffer:ByteArray;
 
-        private var decoderBuffer:ByteArray;
+        private var _decoderBuffer:ByteArray;
 
         private var ansiForegroundColors:Array;    // Array of RGB, length must be 7
@@ -62 +61 @@
 
         // IDataOutput interface
-        private var _objectEncoding:uint;
-        private var _endian:String;
+        private var _middleBuffer:ByteArray;
 
         /**
@@ -121 +119 @@
                 fontCalibration();
 
-                resize(col, row);
-
                 // FIXME
                 characterWidthMeasure = new TextField();
@@ -129 +125 @@
 
                 drawBuffer = new ByteArray();
-                decoderBuffer = new ByteArray();
-
-                _objectEncoding = decoderBuffer.objectEncoding;
-                _endian = decoderBuffer.endian;
-        
-                telnetClient = new FxTelnet();
-                telnetClient.addEventListener(ProgressEvent.SOCKET_DATA, dataHandler);
-                telnetClient.connect("127.0.0.1", 5000);
-                this.addEventListener(KeyboardEvent.KEY_DOWN, keyboardHandler);
+                _decoderBuffer = new ByteArray();
+                _middleBuffer = new ByteArray();
+
+                resize(col, row);
         }
 
@@ -150 +141 @@
                 fontCalibration();
                 adjustDisplay();
-                for(var r:uint = 0; r < rows; ++r) {
-                        lineDirty[r] = true;
-                }
-                cursorDirty = true;
-                refresh();
+        }
+
+        /**
+         * Get font size.
+         */
+        public function get fontSize():Object
+        {
+                return displayTextFormat.size;
         }
 
@@ -205 +199 @@
 
         /**
+         * Get number of columns
+         */
+        public function get col():uint
+        {
+                return cols;
+        }
+
+        /**
          * Set number of columns
          */
@@ -213 +215 @@
 
         /**
+         * Get number of rows
+         */
+        public function get row():uint
+        {
+                return rows;
+        }
+
+        /**
          * Set number of rows
          */
@@ -218 +228 @@
         {
                 resize(cols, n);
-        }
-
-        // FIXME
-        private function keyboardHandler(event:KeyboardEvent):void
-        {
-                if( event.charCode == 0 ) { return; }
-                telnetClient.writeByte(event.charCode);
         }
 
@@ -234 +237 @@
         public function resize(newcols:uint, newrows:uint):void
         {
+                if( newcols <= 1 ) { newcols = 1; }
+                if( newrows <= 1 ) { newrows = 1; }
+
                 screen.length = newrows;
                 lineDirty.length = newrows;
@@ -256 +262 @@
                                 tf.selectable = true;
                                 tf.x = 0;
-                                tf.y = lineHeight * r;
+                                // tf.y will be set at adjustDisplay()
                                 addChild(tf);
                         }
@@ -287 +293 @@
                 rows = newrows;
 
-                for(r = 0; r < rows; ++r) {
-                        lineDirty[r] = true;
-                }
-
-                adjustDisplay();
+                if( ccol >= cols ) { ccol = cols - 1; }
+                if( crow >= rows ) { crow = rows - 1; }
 
                 // FIXME
                 scrolltop = 0;
                 scrollbottom = rows - 1;
+
+                adjustDisplay();
         }
 
@@ -314 +319 @@
         {
                 var dwidth:Number  = calibrateFontWidth  * cols;
-                var dheight:Number = calibrateFontHeight * rows;
+                var dheight:Number = lineHeight * rows + lineGapFilling;
                 background.bitmapData = new BitmapData(
                                 dwidth,
@@ -323 +328 @@
                 //cursorCanvas.width = dwidth;
                 //cursorCanvas.height = dheight;
+                //this.width = dwidth;
+                //this.height = dheight;
+                for(var r:uint = 0; r < rows; ++r) {
+                        fieldArray[r].y = lineHeight * r;
+                }
+                refresh(true);  // force refresh
         }
 
@@ -328 +339 @@
         /**
          * refresh the console
-         */
-        public function refresh():void
-        {
+         * @param force  force redraw whole screen
+         */
+        public function refresh(force:Boolean = true):void
+        {
+                if(force) {
+                        for(var f:uint = 0; f < rows; ++f) {
+                                lineDirty[f] = true;
+                        }
+                }
+
                 var field:TextField;
                 var attr:uint = screen[0][0];
@@ -359 +377 @@
 
                 // draw cursor
-                if( cursorDirty ) {
+                if( cursorDirty || force ) {
                         cursorDirty = false;
                         cursorCanvas.graphics.clear();
-                        cursorCanvas.graphics.beginFill(ansiForegroundColors[0], 1.0);   // FIXME  cursor color
+                        // FIXME  cursor color
+                        cursorCanvas.graphics.beginFill(ansiForegroundColors[0], 1.0);
                         cursorCanvas.graphics.drawRect(
                                         (this.width / cols - 0.05) * ccol + 2,
@@ -412 +431 @@
         public function writeBytes(bytes:ByteArray, offset:uint = 0, length:uint = 0):void
         {
-                var decoder:ByteArray = decoderBuffer;
+                var decoder:ByteArray = _decoderBuffer;
                 var c:String;
                 var len:uint = (length != 0 ? length : bytes.length);
@@ -454 +473 @@
         }
 
-
-// FIXME
-        private function dataHandler(event:ProgressEvent):void
-        {
-                var buffer:ByteArray = telnetClient.buffer;
-                var len:uint = buffer.length;
-                buffer.position = 0;
-
-                var decoder:ByteArray = decoderBuffer;
-                var c:String;
-                for(var n:uint = 0; n < len; ++n) {
-                        var b:uint = buffer[n];
-                        if( escaped ) {
-                                // escape sequence
-                                escapeSequence.writeByte(b);
-                                tryInterpretEscapeSequence();
-                        } else if( decoder.length == 0 ) {
-                                if( b >= 1 && b <= 31 ) {
-                                        // control character
-                                        handleControlChar(b);
-                                } else if( b <= 0x7F ) {
-                                        // single byte character
-                                        if( b != 0 ) {  // ignore NULL
-                                                c = String.fromCharCode(b); // FIXME
-                                                // TODO: graphmode
-                                                putNormalCharacter(c);
-                                        }
-                                } else {
-                                        // first byte of multibyte character
-                                        decoder.writeByte(b);
-                                }
-                        } else {
-                                decoder.position = decoder.length;
-                                decoder.writeByte(b);
-                                try {
-                                        decoder.position = 0;
-                                        c = decoder.readMultiByte(decoder.length, charSet);
-                                        if( c.length > 0 ) {
-                                                // complete multibyte character
-                                                decoder.length = 0;
-                                                putNormalCharacter(c);
-                                        }
-                                } catch (e:Error) {
-                                        // insufficient data to complete multibyte character
-                                }
-                        }
-                }
-
-                buffer.length = 0;
-                refresh();  // FIXME
-        }
-
         private function cursorLineDown():void
         {
@@ -1133 +1100 @@
 
         // FIXME  how ad-hoc!
+        // FIXME  this method doesn't work when font size is very small
         private function isWideCharacter(c:String):Boolean
         {
@@ -1205 +1173 @@
         public function set objectEncoding(value:uint):void
         {
-                _objectEncoding = value;
+                _middleBuffer.objectEncoding = value;
         }
         public function get objectEncoding():uint
         {
-                return _objectEncoding;
+                return _middleBuffer.objectEncoding;
         }
 
         public function set endian(value:String):void
         {
-                _endian = value;
+                _middleBuffer.endian = value;
         }
         public function get endian():String
         {
-                return _endian;
+                return _middleBuffer.endian;
         }
 
         public function writeBoolean(value:Boolean):void
         {
-                var bytes:ByteArray = new ByteArray();
-                bytes.writeBoolean(value);
-                writeBytes(bytes);
+                var buffer:ByteArray = _middleBuffer;
+                buffer.writeBoolean(value);
+                writeBytes(buffer);
+                buffer.length = 0;
         }
 
         public function writeByte(value:int):void
         {
-                var bytes:ByteArray = new ByteArray();
-                bytes.endian = _endian;
-                bytes.writeByte(value);
-                writeBytes(bytes);
+                var buffer:ByteArray = _middleBuffer;
+                buffer.writeByte(value);
+                writeBytes(buffer);
+                buffer.length = 0;
         }
 
         public function writeDouble(value:Number):void
         {
-                var bytes:ByteArray = new ByteArray();
-                bytes.endian = _endian;
-                bytes.writeDouble(value);
-                writeBytes(bytes);
+                var buffer:ByteArray = _middleBuffer;
+                buffer.writeDouble(value);
+                writeBytes(buffer);
+                buffer.length = 0;
         }
 
         public function writeFloat(value:Number):void
         {
-                var bytes:ByteArray = new ByteArray();
-                bytes.endian = _endian;
-                bytes.writeFloat(value);
-                writeBytes(bytes);
+                var buffer:ByteArray = _middleBuffer;
+                buffer.writeFloat(value);
+                writeBytes(buffer);
+                buffer.length = 0;
         }
 
         public function writeInt(value:int):void
         {
-                var bytes:ByteArray = new ByteArray();
-                bytes.endian = _endian;
-                bytes.writeInt(value);
-                writeBytes(bytes);
+                var buffer:ByteArray = _middleBuffer;
+                buffer.writeInt(value);
+                writeBytes(buffer);
+                buffer.length = 0;
         }
 
         public function writeMultiByte(value:String, charSet:String):void
         {
-                var bytes:ByteArray = new ByteArray();
-                bytes.endian = _endian;
-                bytes.writeMultiByte(value, charSet);
-                writeBytes(bytes);
+                var buffer:ByteArray = _middleBuffer;
+                buffer.writeMultiByte(value, charSet);
+                writeBytes(buffer);
+                buffer.length = 0;
         }
 
         public function writeObject(object:*):void
         {
-                var bytes:ByteArray = new ByteArray();
-                bytes.endian = _endian;
-                bytes.objectEncoding = _objectEncoding;
-                bytes.writeObject(object);
-                writeBytes(bytes);
+                var buffer:ByteArray = _middleBuffer;
+                buffer.writeObject(object);
+                writeBytes(buffer);
+                buffer.length = 0;
         }
 
         public function writeShort(value:int):void
         {
-                var bytes:ByteArray = new ByteArray();
-                bytes.endian = _endian;
-                bytes.writeShort(value);
-                writeBytes(bytes);
+                var buffer:ByteArray = _middleBuffer;
+                buffer.writeShort(value);
+                writeBytes(buffer);
+                buffer.length = 0;
         }
 
         public function writeUnsignedInt(value:uint):void
         {
-                var bytes:ByteArray = new ByteArray();
-                bytes.endian = _endian;
-                bytes.writeUnsignedInt(value);
-                writeBytes(bytes);
+                var buffer:ByteArray = _middleBuffer;
+                buffer.writeUnsignedInt(value);
+                writeBytes(buffer);
+                buffer.length = 0;
         }
 
         public function writeUTF(value:String):void
         {
-                var bytes:ByteArray = new ByteArray();
-                bytes.endian = _endian;
-                bytes.writeUTF(value);
-                writeBytes(bytes);
+                var buffer:ByteArray = _middleBuffer;
+                buffer.writeUTF(value);
+                writeBytes(buffer);
+                buffer.length = 0;
         }
 
         public function writeUTFBytes(value:String):void
         {
-                var bytes:ByteArray = new ByteArray();
-                bytes.endian = _endian;
-                bytes.writeUTFBytes(value);
-                writeBytes(bytes);
+                var buffer:ByteArray = _middleBuffer;
+                buffer.writeUTFBytes(value);
+                writeBytes(buffer);
+                buffer.length = 0;
         }
 

lang/actionscript/FxTerm/trunk/FxTermTest.mxml

@@ -1 +1 @@
 <?xml version="1.0" encoding="utf-8"?>
-<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" creationComplete="init()" layout="vertical" xmlns="*">
+<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml"
+                creationComplete="init()" layout="vertical" xmlns="*"
+        >
+        <mx:Style>
+                Application {
+                        backgroundColor: #999999;
+                }
+                .terminalPanel {
+                        color: #0f0f0f;
+                        backgroundColor: #000000;
+                }
+                .terminalControlLink {
+                        color: #606060;
+                        disabledColor: #0f0f0f;
+                        selectionColor: #000000;
+                        separatorColor: #CCCCC4;
+                }
+        </mx:Style>
         <mx:Script>
-                import FxTerm;
-                import Terminal;
+        <![CDATA[
                 import mx.controls.*;
                 import mx.containers.*;
-                private var term:FxTerm;
+                import flash.events.*;
+                import mx.events.*;
+                import mx.core.*;
                 private function init():void
                 {
+                        terminal.addEventListener(KeyboardEvent.KEY_DOWN, keyboardHandler);
+                        terminal.addEventListener(ResizeEvent.RESIZE, terminalResizedHandler);
+                        commandLine.tabEnabled = false;
+                        for each(var c:UIComponent in terminalControlLink.getChildren()) {
+                                c.tabEnabled = false;
+                        }
                 }
+
+                private function keyboardHandler(event:KeyboardEvent):void
+                {
+                        var code:uint = event.charCode;
+                        if(code == 0) { return; }
+                        telnet.writeByte(code);
+                }
+
+                private function terminalResizedHandler(event:ResizeEvent):void
+                {
+                        trace("resized");
+                }
+
+                private var hasCommandLineInput:Boolean = false;
+                private function onCommandLineInput(event:TextEvent):void
+                {
+                        hasCommandLineInput = true;  // 漢字変換中は送信しない
+                        // http://aoi-project.com/pblog/article.php?id=11
+                }
+                private function onCommandLineKeyUp(event:KeyboardEvent):void {
+                        if (event.keyCode == Keyboard.ENTER &&
+                                        hasCommandLineInput == false) {
+                                trace(commandLine.text);
+                                if(commandLine.text.length == 0) {
+                                        // send enter key
+                                        telnet.writeByte(Keyboard.ENTER);
+                                } else {
+                                        // send text
+                                        telnet.writeUTFBytes(commandLine.text);
+                                        commandLine.text = "";
+                                }
+                        }
+                        hasCommandLineInput = false;
+                }
+        ]]>
         </mx:Script>
-        <!--<mx:Script source="FxTerm.as" />-->
-        <!--<mx:Style source="FxTerm.css" />-->
-        <Terminal id="kk" col="80" row="20"/>
-        <!--<mx:HBox id="pa" />-->
-        <!--<mx:VBox id="term" width="800" height="400"/>-->
-        <!--<mx:Text id="term" width="800" height="400"/>-->
-        <!--<mx:TextArea id="log" width="800" height="100%"/>-->
+        <TelnetService id="telnet" host="localhost" port="5000"/>
+        <mx:Panel id="terminalPanel" styleName="terminalPanel">
+                <Terminal id="terminal" col="80" row="20" dataProvider="{telnet}"/>
+                <mx:ControlBar><mx:VBox width="100%" horizontalAlign="center">
+                        <mx:LinkBar id="terminalControlLink" styleName="terminalControlLink"
+                                dataProvider="terminalControl"/>
+                        <mx:ViewStack id="terminalControl" width="100%" minWidth="400">
+                                <mx:HBox label="Command" width="100%">
+                                        <mx:TextInput width="100%" id="commandLine"
+                                                textInput="onCommandLineInput(event)"
+                                                keyUp="onCommandLineKeyUp(event)"
+                                                />
+                                </mx:HBox>
+                                <mx:HBox label="Size" horizontalAlign="center">
+                                        <mx:Label text="Colmuns" styleName="terminalControlLabel"/>
+                                        <mx:NumericStepper value="{terminal.col}" minimum="1" maximum="400" id="colmunStepper"
+                                                change="terminal.col=colmunStepper.value"
+                                                styleName="terminalControl"/>
+                                        <mx:Spacer width="10"/>
+                                        <mx:Label text="Rows" styleName="terminalControlLabel"/>
+                                        <mx:NumericStepper value="{terminal.row}" minimum="1" maximum="40" id="rowStepper"
+                                                change="terminal.row=rowStepper.value"
+                                                styleName="terminalControl"/>
+                                        <mx:Spacer width="10"/>
+                                        <mx:Label text="Font size" styleName="terminalControlLabel"/>
+                                        <mx:NumericStepper value="{terminal.fontSize}" minimum="1" maximum="40" id="fontSizeStepper"
+                                                change="terminal.fontSize=fontSizeStepper.value"
+                                                styleName="terminalControl"/>
+                                </mx:HBox>
+                                <mx:HBox label="Color" width="100%">
+                                </mx:HBox>
+                        </mx:ViewStack>
+                </mx:VBox></mx:ControlBar>
+        </mx:Panel>
 </mx:Application>
 

lang/actionscript/FxTerm/trunk/Telnet.as

@@ -1 +1 @@
 package
 {
-        import flash.events.*;
-        import flash.net.Socket;
-        import flash.utils.ByteArray;
-        import flash.system.Security;
-
-//import mx.controls.*;
-
-        public class FxTelnet implements IEventDispatcher {
-                private var socket:Socket;
-                private var eventDispatcher:EventDispatcher;
-
-                public var buffer:ByteArray;
-                private var state:int = 0;
-                private var is_active:Boolean = false;
-
-                public function get bytesAvailable():uint {
-                        return buffer.length;
-                }
-
-                public function FxTelnet() {
-                        eventDispatcher = new EventDispatcher(this);
-                        buffer = new ByteArray();
-                        socket = new Socket();
-                        socket.addEventListener(Event.CONNECT, connectHandler);
-                        socket.addEventListener(Event.CLOSE, closeHandler);
-                        socket.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);
-                        socket.addEventListener(ProgressEvent.SOCKET_DATA, socketDataHandler);
-                        socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
-                }
-
-                public function connect(server:String, port:int):void {
-                        // Load policy file from remote server.
-                        //Security.loadPolicyFile("http://" + serverURL + "/crossdomain.xml");
-                        //Security.loadPolicyFile("http://xcore.local:9200/crossdomain.xml");
-                        try {
-                                msg("Trying to connect to " + server + ":" + port + "\n");
-                                socket.connect(server, port);
-                                is_active = true;
-                        } catch (error:Error) {
-                                msg(error.message + "\n");
-                                socket.close();
-                        }
-                }
-
-                public function readMultiByte(charSet:String):String {
-                        var buflen:uint = buffer.length;
-                        if( buflen == 0 ) { return ""; }
-                        buffer.position = 0;
-                        var value:String = buffer.readMultiByte(buflen, charSet);
-                        buffer.length = 0;
-                        return value;
-                }
-                public function readBytes(bytes:ByteArray, offset:uint = 0):void {
-                        buffer.position = 0;
-                        buffer.readBytes(bytes, offset, 0);
-                        buffer.length = 0;
-                }
-                public function writeByte(value:int):void
-                {
-                        if( !is_active ) { return; }
-                        socket.writeByte(value);
-                }
-                public function writeMultibyte(value:String):void {
-                        if( !is_active ) { return; }
-                        // 
-                }
-                public function writeBytes(bytes:ByteArray, offset:uint = 0, length:uint = 0):void {
-                        if( !is_active ) { return; }
-                        // 
-                }
-
-                private function connectHandler(event:Event):void {
-                        if (socket.connected) {
-                                msg("connected...\n");
-                        } else {
-                                msg("unable to connect\n");
-                        }
-                }
-                private function closeHandler(event:Event):void {
-                        msg("closed...\n");
-                        is_active = false;
-                }
-                private function ioErrorHandler(event:IOErrorEvent):void {
-                        msg("Unable to connect: socket error.\n");
-                        is_active = false;
-                }
-                private function securityErrorHandler(event:SecurityErrorEvent):void {
-                        //msg(event.text + "\n");
-                        is_active = false;
-                        //Alert.show(event.text);
-                }
-
-                private const WILL:int = 0xFB; // 251 - WILL (option code)
-                private const WONT:int = 0xFC; // 252 - WON'T (option code)
-                private const DO:int   = 0xFD; // 253 - DO (option code)
-                private const DONT:int = 0xFE; // 254 - DON'T (option code)
-                private const IAC:int  = 0xFF; // 255 - Interpret as Command (IAC)
-                private function socketDataHandler(ev:ProgressEvent):void {
-                        var n:int = socket.bytesAvailable;
-                        // Loop through each available byte returned from the socket connection.
-                        while (--n >= 0) {
-                                // Read next available byte.
-                                var b:int = socket.readUnsignedByte();
-                                switch (state) {
-                                        case 0:
-                                                // If the current byte is the "Interpret as Command" code, set the state to 1.
-                                                if (b == IAC) {
-                                                        state = 1;
-                                                        // Else display the character using the msg() method.
-                                                } else {
-                                                        buffer.writeByte(b);
-                                                }
-                                                break;
-                                        case 1:
-                                                // If the current byte is the "DO" code, set the state to 2.
-                                                if (b == DO) {
-                                                        state = 2;
-                                                } else {
-                                                        state = 0;
-                                                }
-                                                break;
-                                                // Blindly reject the option.
-                                        case 2:
-                                                /*
-                                                   Write the "Interpret as Command" code, "WONT" code, 
-                                                   and current byte to the socket and send the contents 
-                                                   to the server by calling the flush() method.
-                                                   */
-                                                socket.writeByte(IAC);
-                                                socket.writeByte(WONT);
-                                                socket.writeByte(b);
-                                                socket.flush();
-                                                state = 0;
-                                                break;
-                                }
-                        }
-                        var event:Event = new ProgressEvent(
-                                        ProgressEvent.SOCKET_DATA,
+
+import flash.events.*;
+import flash.net.Socket;
+import flash.utils.ByteArray;
+import flash.utils.IDataOutput;
+
+public class Telnet extends EventDispatcher implements IDataOutput
+{
+        private var _socket:Socket;
+        private var _buffer:ByteArray;
+        private var _state:int = 0;
+        private var _active:Boolean = false;
+
+        private static const WILL:int = 0xFB; // 251 - WILL (option code)
+        private static const WONT:int = 0xFC; // 252 - WON'T (option code)
+        private static const DO:int   = 0xFD; // 253 - DO (option code)
+        private static const DONT:int = 0xFE; // 254 - DON'T (option code)
+        private static const IAC:int  = 0xFF; // 255 - Interpret as Command (IAC)
+
+        // IDataOutput interface
+        private var _middleBuffer:ByteArray;
+
+        public function Telnet()
+        {
+                _buffer = new ByteArray();
+                _middleBuffer = new ByteArray();
+                var socket:Socket = _socket = new Socket();
+                socket.addEventListener(Event.CONNECT, connectHandler);
+                socket.addEventListener(Event.CLOSE, closeHandler);
+                socket.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);
+                socket.addEventListener(ProgressEvent.SOCKET_DATA, socketDataHandler);
+                socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
+        }
+
+        public function connect(host:String, port:int):void
+        {
+                try {
+                        _socket.connect(host, port);
+                        _active = true;
+                } catch (error:Error) {
+                        _socket.close();
+                        var event:IOErrorEvent = new IOErrorEvent(
+                                        IOErrorEvent.IO_ERROR,
                                         false,
                                         false,
-                                        buffer.length,
-                                        0
+                                        "failed connect to " + host + ":" + port
                                         );
                         dispatchEvent(event);
                 }
-
-                private function msg(value:String):void {
-                        buffer.writeUTFBytes(value);
-                        var event:Event = new ProgressEvent(
-                                        ProgressEvent.SOCKET_DATA,
-                                        false,
-                                        false,
-                                        buffer.length,
-                                        0
-                                        );
-                        dispatchEvent(event);
+        }
+
+        public function close():void
+        {
+                _socket.close();
+                _active = false;
+        }
+
+        public function get bytesAvailable():uint
+        {
+                return _buffer.length;
+        }
+
+        public function readBytes(bytes:ByteArray, offset:uint = 0):void
+        {
+                var buffer:ByteArray = _buffer;
+                buffer.position = 0;
+                buffer.readBytes(bytes, offset, 0);
+                buffer.length = 0;
+        }
+
+
+        public function writeByte(value:int):void
+        {
+                if( !_active ) { return; }
+                if( value == IAC ) {
+                        _socket.writeByte(value);
+                        _socket.writeByte(value);
+                } else {
+                        _socket.writeByte(value);
                 }
-
-
-
-                // delegate EventDispatcher
-                public function addEventListener(type:String,
-                                listener:Function,
-                                useCapture:Boolean = false,
-                                priority:int = 0,
-                                useWeakReference:Boolean = false):void
-                {
-                        eventDispatcher.addEventListener(type, listener, useCapture,
-                                        priority, useWeakReference);
+        }
+
+        public function writeBytes(bytes:ByteArray, offset:uint = 0, length:uint = 0):void {
+                if( !_active ) { return; }
+                _socket.writeBytes(bytes, offset, length);
+                // FIXME convert IAC to IAC IAC
+        }
+
+        private function connectHandler(event:Event):void
+        {
+                dispatchEvent(event);
+        }
+
+        private function closeHandler(event:Event):void
+        {
+                _active = false;
+                dispatchEvent(event);
+        }
+
+        private function ioErrorHandler(event:IOErrorEvent):void
+        {
+                _active = false;
+                dispatchEvent(event);
+        }
+
+        private function securityErrorHandler(event:SecurityErrorEvent):void
+        {
+                _active = false;
+                dispatchEvent(event);
+        }
+
+        private function socketDataHandler(ev:ProgressEvent):void
+        {
+                var socket:Socket = _socket;
+                var buffer:ByteArray = _buffer;
+                var beforeLength:uint = _buffer.length;
+                var state:int = _state;
+                var n:int = socket.bytesAvailable;
+                while (--n >= 0) {
+                        var b:int = socket.readUnsignedByte();
+                        switch (state) {
+                                case 0:
+                                        if (b == IAC) {
+                                                state = 1;
+                                        } else {
+                                                buffer.writeByte(b);
+                                        }
+                                        break;
+                                case 1:
+                                        if (b == DO) {
+                                                state = 2;
+                                        } else {
+                                                state = 0;
+                                        }
+                                        break;
+                                case 2:
+                                        socket.writeByte(IAC);
+                                        socket.writeByte(WONT);
+                                        socket.writeByte(b);
+                                        socket.flush();
+                                        state = 0;
+                                        break;
+                        }
                 }
-
-                public function removeEventListener(type:String,
-                                listener:Function,
-                                useCapture:Boolean = false):void
-                {
-                        eventDispatcher.removeEventListener(type, listener, useCapture);
-                }
-
-                public function dispatchEvent(event:Event):Boolean
-                {
-                        return eventDispatcher.dispatchEvent(event);
-                }
-
-                public function hasEventListener(type:String):Boolean
-                {
-                        return eventDispatcher.hasEventListener(type);
-                }
-
-
-                public function willTrigger(type:String):Boolean
-                {
-                        return eventDispatcher.willTrigger(type);
-                }
+                _state = state;
+                var event:Event = new ProgressEvent(
+                                ProgressEvent.PROGRESS,
+                                false,
+                                false,
+                                buffer.length - beforeLength,
+                                buffer.length
+                                );
+                dispatchEvent(event);
+        }
+
+
+        /**
+         * IDataOutput interface
+         */
+        public function set objectEncoding(value:uint):void
+        {
+                _middleBuffer.objectEncoding = value;
+        }
+        public function get objectEncoding():uint
+        {
+                return _middleBuffer.objectEncoding;
+        }
+
+        public function set endian(value:String):void
+        {
+                _middleBuffer.endian = value;
+        }
+        public function get endian():String
+        {
+                return _middleBuffer.endian;
+        }
+
+        public function writeBoolean(value:Boolean):void
+        {
+                var buffer:ByteArray = _middleBuffer;
+                buffer.writeBoolean(value);
+                writeBytes(buffer);
+                buffer.length = 0;
+        }
+
+        public function writeDouble(value:Number):void
+        {
+                var buffer:ByteArray = _middleBuffer;
+                buffer.writeDouble(value);
+                writeBytes(buffer);
+                buffer.length = 0;
+        }
+
+        public function writeFloat(value:Number):void
+        {
+                var buffer:ByteArray = _middleBuffer;
+                buffer.writeFloat(value);
+                writeBytes(buffer);
+                buffer.length = 0;
+        }
+
+        public function writeInt(value:int):void
+        {
+                var buffer:ByteArray = _middleBuffer;
+                buffer.writeInt(value);
+                writeBytes(buffer);
+                buffer.length = 0;
+        }
+
+        public function writeMultiByte(value:String, charSet:String):void
+        {
+                var buffer:ByteArray = _middleBuffer;
+                buffer.writeMultiByte(value, charSet);
+                writeBytes(buffer);
+                buffer.length = 0;
+        }
+
+        public function writeObject(object:*):void
+        {
+                var buffer:ByteArray = _middleBuffer;
+                buffer.writeObject(object);
+                writeBytes(buffer);
+                buffer.length = 0;
+        }
+
+        public function writeShort(value:int):void
+        {
+                var buffer:ByteArray = _middleBuffer;
+                buffer.writeShort(value);
+                writeBytes(buffer);
+                buffer.length = 0;
+        }
+
+        public function writeUnsignedInt(value:uint):void
+        {
+                var buffer:ByteArray = _middleBuffer;
+                buffer.writeUnsignedInt(value);
+                writeBytes(buffer);
+                buffer.length = 0;
+        }
+
+        public function writeUTF(value:String):void
+        {
+                var buffer:ByteArray = _middleBuffer;
+                buffer.writeUTF(value);
+                writeBytes(buffer);
+                buffer.length = 0;
+        }
+
+        public function writeUTFBytes(value:String):void
+        {
+                var buffer:ByteArray = _middleBuffer;
+                buffer.writeUTFBytes(value);
+                writeBytes(buffer);
+                buffer.length = 0;
         }
 }
+
+}

lang/actionscript/FxTerm/trunk/Terminal.as

@@ -3 +3 @@
 
 import flash.utils.ByteArray;
-import mx.core.UIComponent;
 import flash.utils.IDataOutput;
 import flash.events.Event;
-import TerminalEvent;
+import flash.events.ProgressEvent;
+import flash.text.TextFormat;
+
+import mx.core.UIComponent;
+import mx.events.*;
 
 public class Terminal extends UIComponent implements IDataOutput
 {
-        private var term:FxTerm;
+        private var _term:FxTerm;
         private var _dataProvider:Object;
         private var _buffer:ByteArray;
@@ -18 +21 @@
                 super();
                 _buffer = new ByteArray();
-                term = new FxTerm();
-                this.width = term.width;
-                this.height = term.height;
-                addChild(term);
+                _term = new FxTerm();
+                this.width = _term.width;
+                this.height = _term.height;
+                addChild(_term);
         }
 
         public function set dataProvider(object:Object):void
         {
-                _dataProvider.addEventListener(TerminalEvent.TERMINAL_DATA, dataHandler);
+                if(_dataProvider) {
+                        _dataProvider.removeEventListner(
+                                        ProgressEvent.PROGRESS, dataHandler);
+                }
+                object.addEventListener(ProgressEvent.PROGRESS, dataHandler);
                 _dataProvider = object;
-                if(_dataProvider) {
-                        _dataProvider.removeEventListner(TerminalEvent.TERMINAL_DATA, dataHandler);
-                }
         }
 
-        private function dataHandler(event:TerminalEvent):void
+        private function dataHandler(event:ProgressEvent):void
         {
                 var buffer:ByteArray = _buffer;
@@ -39 +43 @@
                 writeBytes(buffer);
                 refresh();
+                buffer.length = 0;
         }
 
@@ -47 +52 @@
         }
 
-        public function set fontSize(value:Object):void
-                { term.fontSize = value; }
+        private function resized():void
+        {
+                this.width = _term.width;
+                this.height = _term.height;
+        }
+
+        [Bindable]
+        public function get charSet():String
+                { return _term.charSet; }
+        public function set charSet(charset:String):void
+                { _term.charSet = charset; }
+
+        public function set textFormat(format:TextFormat):void
+                { _term.textFormat = format; resized(); }
+
+        [Bindable]
+        public function get fontSize():Number
+                { return Number(_term.fontSize); }
+        public function set fontSize(value:Number):void
+                { _term.fontSize = value as Object; resized(); }
+
         public function set foregroundColors(color8:Array):void
-                { term.foregroundColors = color8; }
+                { _term.foregroundColors = color8; }
         public function set backgroundColors(color8:Array):void
-                { term.backgroundColors = color8; }
+                { _term.backgroundColors = color8; }
         public function setForegroundColor(n:uint, color:uint):uint
-                { return term.setForegroundColor(n, color); }
+                { return _term.setForegroundColor(n, color); }
         public function setBackgroundColor(n:uint, color:uint):uint
-                { return term.setBackgroundColor(n, color); }
+                { return _term.setBackgroundColor(n, color); }
 
         public function resize(cols:uint, rows:uint):void
-                { term.resize(cols, rows); changed(); }
+                { _term.resize(cols, rows); changed(); resized(); }
+
+        [Bindable]
+        public function get col():uint
+                { return _term.col; }
         public function set col(n:uint):void
-                { term.col = n; changed(); }
+                { _term.col = n; changed(); resized(); }
+
+        [Bindable]
+        public function get row():uint
+                { return _term.row; }
         public function set row(n:uint):void
-                { term.row = n; changed(); }
-        public function refresh():void
-                { term.refresh(); changed(); }
+                { _term.row = n; changed(); resized(); }
+
+        public function refresh(force:Boolean = true):void
+                { _term.refresh(force); changed(); }
 
         public function set objectEncoding(value:uint):void
-                { term.objectEncoding = value; }
+                { _term.objectEncoding = value; }
         public function get objectEncoding():uint
-                { return term.objectEncoding }
+                { return _term.objectEncoding }
+
         public function set endian(value:String):void
-                { term.endian = value; }
+                { _term.endian = value; }
         public function get endian():String
-                { return term.endian; }
+                { return _term.endian; }
+
         public function writeBytes(bytes:ByteArray, offset:uint = 0, length:uint = 0):void
-                { term.writeBytes(bytes, offset, length); }
+                { _term.writeBytes(bytes, offset, length); }
         public function writeBoolean(value:Boolean):void
-                { term.writeBoolean(value); }
+                { _term.writeBoolean(value); }
         public function writeByte(value:int):void
-                { term.writeByte(value); }
+                { _term.writeByte(value); }
         public function writeDouble(value:Number):void
-                { term.writeDouble(value); }
+                { _term.writeDouble(value); }
         public function writeFloat(value:Number):void
-                { term.writeFloat(value); }
+                { _term.writeFloat(value); }
         public function writeInt(value:int):void
-                { term.writeInt(value); }
+                { _term.writeInt(value); }
         public function writeMultiByte(value:String, charSet:String):void
-                { term.writeMultiByte(value, charSet); }
+                { _term.writeMultiByte(value, charSet); }
         public function writeObject(object:*):void
-                { term.writeObject(object); }
+                { _term.writeObject(object); }
         public function writeShort(value:int):void
-                { term.writeShort(value); }
+                { _term.writeShort(value); }
         public function writeUnsignedInt(value:uint):void
-                { term.writeUnsignedInt(value); }
+                { _term.writeUnsignedInt(value); }
         public function writeUTF(value:String):void
-                { term.writeUTF(value); }
+                { _term.writeUTF(value); }
         public function writeUTFBytes(value:String):void
-                { term.writeUTFBytes(value); }
+                { _term.writeUTFBytes(value); }
 }