package jp.playwell.controls
{
    import jp.playwell.skins.ToolBarButtonSkin;
 
    import spark.components.Button;
 
    [Style(name="icon", type="Class", inherit="no")]
 
    public class ToolBarButton extends Button
    {
        public function ToolBarButton()
        {
            super();
            setStyle("skinClass", ToolBarButtonSkin);
        }
    }
}

<?xml version="1.0" encoding="utf-8"?>
<s:SparkSkin
    xmlns:fx="http://ns.adobe.com/mxml/2009"
    xmlns:s="library://ns.adobe.com/flex/spark"
    minWidth="21" minHeight="21"
    alpha.disabled="0.5">
 
    <!-- states -->
    <s:states>
        <s:State name="up" />
        <s:State name="over" />
        <s:State name="down" />
        <s:State name="disabled" />
    </s:states>
 
    <!-- host component -->
    <fx:Metadata>
        [HostComponent("jp.playwell.controls.ToolBarButton")]
    </fx:Metadata>
 
    <fx:Script>
        <![CDATA[
            static private const exclusions:Array = ["labelElement"];
 
            override public function get colorizeExclusions():Array {
                return exclusions;
            }
        ]]>
    </fx:Script>
 
    <!-- layer 1: fill -->
    <s:Rect top="0" height="23" horizontalCenter="0" width="45"
            radiusX="11.5" radiusY="11.5">
        <s:fill>
            <s:LinearGradient rotation="90">
                <s:GradientEntry color="0xE6E7E8"
                        alpha="1" alpha.over="0.7" alpha.down="0.4"/>
                <s:GradientEntry color="0xC7CBCE"
                        alpha="1" alpha.over="0.7" alpha.down="0.4"/>
                <s:GradientEntry color="0xD9DCE0"
                        alpha="1" alpha.over="0.7" alpha.down="0.4"/>
            </s:LinearGradient>
        </s:fill>
    </s:Rect>
 
    <!-- layer 2: border -->
    <s:Rect top="1" horizontalCenter="0"
            width="45" height="23"
            radiusX="11.5" radiusY="11.5">
        <s:stroke>
            <s:SolidColorStroke color="0xFFFFFF" alpha="0.4"/>
        </s:stroke>
    </s:Rect>
    <s:Rect top="0" horizontalCenter="0"
            width="45" height="23"
            radiusX="11.5" radiusY="11.5">
        <s:stroke>
            <s:LinearGradientStroke rotation="90">
                <s:GradientEntry color="0x000000" alpha="0.4"/>
                <s:GradientEntry color="0x000000" alpha="0.1"/>
            </s:LinearGradientStroke>
        </s:stroke>
    </s:Rect>
 
    <!-- layer 3: icon -->
    <s:BitmapImage source="{hostComponent.getStyle('icon')}"
        horizontalCenter="0" top="2"/>
 
    <!-- layer 4: text -->
    <s:SimpleText
        fontSize="11.5"
        textAlign="center" color="#FFFFFF"
        verticalAlign="middle" alpha="0.4"
        horizontalCenter="0" text="{hostComponent.label}"
        left="10" right="10" top="29" />
    <s:SimpleText id="labelElement"
        fontSize="11.5"
        textAlign="center"
        verticalAlign="middle"
        horizontalCenter="0"
        left="10" right="10" top="28" />
 
</s:SparkSkin>

<controls:ToolBarButton label="Get Mail" icon="@Embed(source='assets/mail.png')"/>
<controls:ToolBarButton label="New Message" icon="@Embed(source='assets/mail_new.png')"/>
<controls:ToolBarButton label="Delete" icon="@Embed(source='assets/delete.png')"/>
<controls:ToolBarButton label="Junk" icon="@Embed(source='assets/mail_junk.png')"/>

package mx.core
{
public interface IMXMLObject
{
    function initialized(document:Object, id:String):void;
}
}

<?xml version="1.0" encoding="utf-8"?>
<mx:VBox
    xmlns:mx="http://www.adobe.com/2006/mxml"
    width="400" height="300"
    horizontalAlign="center" verticalAlign="middle">
    <mx:Button id="button" label="ボタン"/>
</mx:VBox>

package views.helpers
{
    import flash.events.MouseEvent;
 
    import mx.controls.Alert;
    import mx.core.IMXMLObject;
    import mx.events.FlexEvent;
 
    import views.MyCustomComponent;
 
    public class MyCustomComponentHelper implements IMXMLObject
    {
        private var view:MyCustomComponent;
 
        public function MyCustomComponentHelper()
        {
        }
 
        public function initialized(document:Object, id:String):void
        {
            view = document as MyCustomComponent;
            view.addEventListener(FlexEvent.CREATION_COMPLETE,
                creationCompleteHandler);
        }
 
        private function creationCompleteHandler(event:FlexEvent):void
        {
            view.button.addEventListener(MouseEvent.CLICK,
                button_clickHandler);
        }
 
        private function button_clickHandler(event:MouseEvent):void
        {
            Alert.show("ボタンがクリックされたよ");
        }
    }
}

<?xml version="1.0" encoding="utf-8"?>
<mx:VBox
    xmlns:mx="http://www.adobe.com/2006/mxml"
    xmlns:helpers="views.helpers.*"
    width="400" height="300"
    horizontalAlign="center" verticalAlign="middle">
    <helpers:MyCustomComponentHelper id="helper"/>
    <mx:Button id="button" label="ボタン"/>
</mx:VBox>

<?xml version="1.0" encoding="utf-8"?>
<mx:Application
    xmlns:mx="http://www.adobe.com/2006/mxml"
    xmlns:views="views.*"
    layout="absolute"
    <views:MyCustomComponent/>
</mx:Application>

<?xml version="1.0" encoding="utf-8"?>
<mx:VBox
    xmlns:mx="http://www.adobe.com/2006/mxml"
    width="400" height="300">
    <mx:Button id="button" label="ボタン"/>
</mx:VBox>

package views
{
    import flash.events.MouseEvent;
 
    import mx.controls.Alert;
    import mx.events.FlexEvent;
 
    import views.mxml.MyCustomComponentView;
 
    public class MyCustomComponent extends MyCustomComponentView
    {
        public function MyCustomComponent()
        {
            super();
            addEventListener(FlexEvent.CREATION_COMPLETE,
                creationCompleteHandler);
        }
 
        private function creationCompleteHandler(event:FlexEvent):void
        {
            button.addEventListener(MouseEvent.CLICK,
                button_clickHandler);
        }
 
        private function button_clickHandler(event:MouseEvent):void
        {
            Alert.show("ボタンがクリックされたよ");
        }
    }
}

package jp.playwell.containers
{
    import flash.display.Graphics;
    import flash.display.Sprite;
    import flash.events.MouseEvent;
    import flash.geom.Rectangle;
 
    import mx.containers.Panel;
 
    public class ResizablePanel extends Panel
    {
        protected var resizeHandle:Sprite;
 
        public function ResizablePanel()
        {
            super();
        }
 
        //--------------------------------------
        // resizable
        //--------------------------------------
        private var _resizable:Boolean = true;
 
        [Bindable]
        [Inspectable(category="General",
            enumeration="true,false", defaultValue="true")]
        /**
         * resizable プロパティが true の場合、リサイズできます。
         * @default true
         */
        public function get resizable():Boolean
        {
            return _resizable;
        }
        public function set resizable(value:Boolean):void
        {
            _resizable = value;
            invalidateDisplayList();
        }
 
        //--------------------------------------
        // protected methods
        //--------------------------------------
        override protected function createChildren():void
        {
            super.createChildren();
 
            if (!resizeHandle)
            {
                resizeHandle = new Sprite();
                resizeHandle.alpha = 0.6;
 
                // ドラッグハンドルを描画
                var g:Graphics = resizeHandle.graphics;
                g.beginFill(0xFFFFFF, 0.0);
                g.drawRect(0, 0, 15, 15);
                g.endFill();
                g.lineStyle(0, 0x111111);
                g.moveTo(3, 14);
                g.lineTo(14, 3);
                g.moveTo(7, 14);
                g.lineTo(14, 7);
                g.moveTo(11, 14);
                g.lineTo(14, 11);
                g.lineStyle(0, 0xFFFFFF);
                g.moveTo(4, 14);
                g.lineTo(14, 4);
                g.moveTo(8, 14);
                g.lineTo(14, 8);
                g.moveTo(12, 14);
                g.lineTo(14, 12);
 
                rawChildren.addChild(resizeHandle);
 
                resizeHandle.addEventListener(MouseEvent.MOUSE_DOWN,
                    resizeHandle_mouseDownHandler);
            }
        }
 
        override protected function updateDisplayList(unscaledWidth:Number,
            unscaledHeight:Number):void
        {
            super.updateDisplayList(unscaledWidth, unscaledHeight);
 
            resizeHandle.visible = resizable;
            resizeHandle.x = unscaledWidth - resizeHandle.width;
            resizeHandle.y = unscaledHeight - resizeHandle.height;
        }
 
        //--------------------------------------
        // ドラッグ処理
        //--------------------------------------
        private var dragData:Rectangle;
        private function resizeHandle_mouseDownHandler(event:MouseEvent):void
        {
            dragData = new Rectangle(stage.mouseX, stage.mouseY,
                unscaledWidth, unscaledHeight);
            stage.addEventListener(MouseEvent.MOUSE_UP, stage_mouseUpHandler);
            stage.addEventListener(MouseEvent.MOUSE_MOVE, stage_mouseMoveHandler);
        }
        private function stage_mouseUpHandler(event:MouseEvent):void
        {
            dragData = null;
            stage.removeEventListener(MouseEvent.MOUSE_UP, stage_mouseUpHandler);
            stage.removeEventListener(MouseEvent.MOUSE_MOVE, stage_mouseMoveHandler);
        }
        private function stage_mouseMoveHandler(event:MouseEvent):void
        {
            if (!resizable) return;
            var w:Number = dragData.width + stage.mouseX - dragData.x;
            var h:Number = dragData.height + stage.mouseY - dragData.y;
 
            width = Math.min(maxWidth, Math.max(minWidth, resizeHandle.width, w));
            height = Math.min(maxHeight, Math.max(minHeight, resizeHandle.height, h));
        }
    }
}

package jp.playwell.controls
{
    import flash.display.DisplayObject;
    import flash.events.Event;
    import flash.events.MouseEvent;
 
    import mx.controls.LinkButton;
    import mx.core.UIComponent;
    import mx.styles.CSSStyleDeclaration;
    import mx.styles.StyleManager;
 
    //--------------------------------------
    //  Styles
    //--------------------------------------
    include "../styles/metadata/FocusStyles.as"
    include "../styles/metadata/PaddingStyles.as"
    include "../styles/metadata/LeadingStyle.as"
    include "../styles/metadata/TextStyles.as"
 
    /**
     * リンクの色です.
     * 
     * @default 0x003399
     */
    [Style(name="linkColor", type="uint", format="Color", inherit="yes")]
 
    //--------------------------------------
    //  Events
    //--------------------------------------
    [Event(name="change", type="flash.events.Event")]
 
    /**
     * 
     */
    public class PageNavigator extends UIComponent
    {
        /**
         * デフォルトスタイルを設定
         * @private
         */
        private static var classConstructed:Boolean = classConstruct();
 
        /**
         * @private
         */
        private static function classConstruct():Boolean
        {
            var styleDeclaration:CSSStyleDeclaration = new CSSStyleDeclaration();
            styleDeclaration.setStyle("linkColor", 0x003399);
            StyleManager.setStyleDeclaration("PageNavigator",
                styleDeclaration, true);
            return true;
        }
 
        /**
         * コンストラクタです.
         */
        public function PageNavigator()
        {
            super();
        }
 
        //---------------------------------------
        //  private properties
        //---------------------------------------
        private var valueChanged:Boolean;
 
 
        //---------------------------------------
        //  prevLabel
        //---------------------------------------
        private var _prevLabel:String = "<";
 
        [Bindable]
        /**
         * prevLabel プロパティは前のページに戻るリンクのテキストです.
         * @default <
         */
        public function get prevLabel():String
        {
            return _prevLabel;
        }
        public function set prevLabel(value:String):void
        {
            _prevLabel = value;
            valueChanged = true;
            invalidateProperties();
            invalidateSize();
            invalidateDisplayList();
        }
 
 
        //---------------------------------------
        //  nextLabel
        //---------------------------------------
        private var _nextLabel:String = ">";
 
        [Bindable]
        /**
         * nextLabel プロパティは次のページに進むリンクのテキストです.
         * @default >
         */
        public function get nextLabel():String
        {
            return _nextLabel;
        }
        public function set nextLabel(value:String):void
        {
            _nextLabel = value;
            valueChanged = true;
            invalidateProperties();
            invalidateSize();
            invalidateDisplayList();
        }
 
 
        //---------------------------------------
        //  sidePages
        //---------------------------------------
        private var _showPages:Number = 11;
 
        /**
         * showPages プロパティは最大何ページ分のリンクを表示するかを指定します.
         * @default 11 （現在のページ + 10ページ分）
         */
        public function get showPages():Number
        {
            return _showPages;
        }
        public function set showPages(value:Number):void
        {
            _showPages = value;
            valueChanged = true;
            invalidateProperties();
            invalidateSize();
            invalidateDisplayList();
        }
 
 
        //---------------------------------------
        //  maximum
        //---------------------------------------
        private var _maximum:uint = 1;
 
        [Bindable]
        /**
         * maximum プロパティは最大ページ数を指定します.
         * @default 1
         */
        public function get maximum():uint
        {
            return _maximum;
        }
        public function set maximum(value:uint):void
        {
            _maximum = value;
            valueChanged = true;
            invalidateProperties();
            invalidateSize();
            invalidateDisplayList();
        }
 
        //---------------------------------------
        //  value
        //---------------------------------------
        private var _page:uint = 1;
 
        [Bindable]
        /**
         * page プロパティは現在のページを指定します.
         * @default 1
         */
        public function get page():uint
        {
            return _page;
        }
        public function set page(value:uint):void
        {
            _page = value;
            valueChanged = true;
            invalidateProperties();
            invalidateSize();
            invalidateDisplayList();
        }
 
 
        //---------------------------------------
        //  override protected methods
        //---------------------------------------
        override protected function commitProperties():void
        {
            super.commitProperties();
 
            if (valueChanged)
            {
                valueChanged = false;
                while (numChildren > 0) removeEventListeners(removeChildAt(0));
 
                _maximum = isNaN(maximum) ? 1 : uint(maximum);
                _page = isNaN(page) ? 1 : Math.min(maximum, uint(page));
 
                var leftPages:uint = Math.floor((showPages - 1) / 2);
                var rightPages:uint = Math.ceil((showPages - 1) / 2);
                var min:uint = Math.max(1, page - leftPages);
                var max:uint = min + showPages - 1;
                if (max > maximum)
                {
                    min = Math.max(1, min - max + maximum);
                    max = maximum;
                }
 
                if (maximum > 1)
                {
                    if (page > 1) addLink(prevLabel);
 
                    var link:LinkButton;
                    for (var i:uint = min; i <= max; i++)
                    {
                        link = addLink(i.toString());
                        if (i == page)
                        {
                            link.mouseEnabled = false;
                            link.setStyle("textDecoration", "none");
                            link.setStyle("color", getStyle("color"));
                        }
                    }
 
                    if (page < maximum) addLink(nextLabel);
                }
            }
        }
        override protected function measure():void
        {
            super.measure();
 
            var w:uint = 0;
            var h:uint = 0;
 
            var n:uint = numChildren;
            var child:DisplayObject;
            for (var i:uint = 0; i < n; i++)
            {
                child = getChildAt(i);
                if (child is UIComponent)
                {
                    w += UIComponent(child).measuredWidth;
                    h = Math.max(h, UIComponent(child).measuredHeight);
                }
            }
 
            measuredWidth = measuredMinWidth = w;
            measuredHeight = measuredMinHeight = h;
        }
        override protected function updateDisplayList(w, h):void
        {
            super.updateDisplayList(w, h);
 
            var left:uint = 0;
            var n:uint = numChildren;
            var child:DisplayObject;
            for (var i:uint = 0; i < n; i++)
            {
                child = getChildAt(i);
                if (child is UIComponent)
                {
                    UIComponent(child).setActualSize(
                        UIComponent(child).measuredWidth,
                        UIComponent(child).measuredHeight);
                    UIComponent(child).move(left,
                        (unscaledHeight - UIComponent(child).measuredHeight) / 2);
                    left = UIComponent(child).x + UIComponent(child).measuredWidth;
                }
            }
        }
 
        override public function setStyle(styleProp:String, newValue:*):void
        {
            super.setStyle(styleProp, newValue);
            switch (styleProp)
            {
                case "color":
                case "linkColor":
                    var n:int = numChildren;
                    var child:DisplayObject;
                    var label:String;
                    for (var i:int = 0; i < n; i++)
                    {
                        child = getChildAt(i);
                        if (!(child is LinkButton)) continue;
                        label = LinkButton(child).label;
                        if (label.match(/^\d+$/))
                        {
                            if (parseInt(label, 10) == page)
                            {
                                LinkButton(child).setStyle("color",
                                    getStyle("color"));
                                continue;
                            }
                        }
                        LinkButton(child).setStyle("color", getStyle("linkColor"));
                    }
                    valueChanged = true;
                    invalidateProperties();
                    break;
            }
        }
 
        //---------------------------------------
        //  private methods
        //---------------------------------------
        /**
         * @private
         */
        private function addLink(label:String):LinkButton
        {
            var linkButton:LinkButton = new LinkButton();
            linkButton.styleName = this;
            linkButton.setStyle("paddingTop", 2);
            linkButton.setStyle("paddingBottom", 2);
            linkButton.setStyle("paddingLeft", 3);
            linkButton.setStyle("paddingRight", 3);
            linkButton.setStyle("textDecoration", "underline");
            linkButton.setStyle("color", getStyle("linkColor"));
            linkButton.label = label;
            linkButton.addEventListener(MouseEvent.CLICK, link_clickHandler);
            addChild(linkButton);
            return linkButton;
        }
        private function removeEventListeners(obj:DisplayObject):void
        {
            obj.removeEventListener(MouseEvent.CLICK, link_clickHandler);
        }
        private function link_clickHandler(event:MouseEvent):void
        {
            var label:String = LinkButton(event.currentTarget).label;
            switch (label)
            {
                case prevLabel:
                    page = page - 1;
                    break;
                case nextLabel:
                    page = page + 1;
                    break;
                default:
                    if (label.match(/^\d+$/))
                        page = parseInt(label, 10);
                    else
                        return;
            }
 
            dispatchEvent(new Event(Event.CHANGE));
        }
    }
}

package jp.playwell.logging
{
    import flash.events.StatusEvent;
    import flash.net.LocalConnection;
 
    import mx.core.mx_internal;
    import mx.logging.ILogger;
    import mx.logging.Log;
    import mx.logging.LogEvent;
    import mx.logging.targets.LineFormattedTarget;
 
    use namespace mx_internal;
 
    public class LoggingTarget extends LineFormattedTarget
    {
        protected var lc:LocalConnection;
        protected var currLevel:uint;
 
        public function LoggingTarget()
        {
            super();
            lc = new LocalConnection();
            lc.addEventListener(StatusEvent.STATUS,
                lc_statusHandler);
            Log.addTarget(this);
        }
        private function lc_statusHandler(event:StatusEvent):void
        {
            //if (event.level == "error")
            //    trace("jp.playwell.logging.LoggingTarget: error");
        }
 
        override public function logEvent(event:LogEvent):void
        {
            currLevel = event.level;
            super.logEvent(event);
        }
        override mx_internal function internalLog(message:String):void
        {
            localConnection.send("_FlexLogger",
                "log", currLevel, message);
        }
    }
}

<?xml version="1.0" encoding="utf-8"?>
<mx:Application
    xmlns:mx="http://www.adobe.com/2006/mxml"
    xmlns:logging="jp.playwell.logging.*"
    layout="vertical" verticalAlign="middle">
    <mx:Script>
        <![CDATA[
            import mx.logging.ILogger;
            import mx.logging.Log;
 
            private function getLogger():ILogger
            {
                return Log.getLogger("LoggingTest");
            }
        ]]>
    </mx:Script>
 
    <logging:LoggingTarget
        includeCategory="true"
        includeLevel="true"
        includeTime="true"/>
 
    <mx:Button label="logger.debug()" width="150"
        click="getLogger().debug('デバッグよ')"/>
    <mx:Button label="logger.info()" width="150"
        click="getLogger().info('情報です')"/>
    <mx:Button label="logger.warn()" width="150"
        click="getLogger().warn('警告だ')"/>
    <mx:Button label="logger.error()" width="150"
        click="getLogger().error('エラーだね')"/>
    <mx:Button label="logger.fatal()" width="150"
        click="getLogger().fatal('致命的なエラーだぜ')"/>
</mx:Application>