<!DOCTYPE html>
<!--
  ~ Copyright 2015 Open Networking Laboratory
  ~
  ~ Licensed under the Apache License, Version 2.0 (the "License");
  ~ you may not use this file except in compliance with the License.
  ~ You may obtain a copy of the License at
  ~
  ~     http://www.apache.org/licenses/LICENSE-2.0
  ~
  ~ Unless required by applicable law or agreed to in writing, software
  ~ distributed under the License is distributed on an "AS IS" BASIS,
  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  ~ See the License for the specific language governing permissions and
  ~ limitations under the License.
  -->

<!--
  ONOS -- SVG mouse over d3 exercise html
  -->

<html>
<head lang="en">
    <meta charset="UTF-8">
    <title>Upgrade Performance</title>

    <script type="text/javascript" src="../tp/angular.js"></script>
    <script type="text/javascript" src="../tp/d3.js"></script>
    <script type="text/javascript" src="svg-exercise.js"></script>
    <script type="text/javascript" src="../app/fw/util/util.js"></script>
    <script type="text/javascript" src="../app/fw/util/fn.js"></script>


    <style>
        html,
        body, div {
            background-color: #eee;
            font-family: Arial, Helvetica, sans-serif;
            font-size: 9pt;
            margin: 0;
            overflow: hidden;
        }
        .button {
            fill: #369;
            filter: url(#buttonBevel);
        }
        svg text {
            fill: white;
            letter-spacing: .005em;
        }
    </style>
</head>

<body ng-app="svgExercise">

<div id="svgExDiv" ng-controller="svgExCtrl as ctrl">
    <improve-performance></improve-performance>
</div>

<svg xmlns="http://www.w3.org/2000/svg"
     viewBox="-10 -10 110 110"
     visibility="hidden">
    <filter id="buttonBevel"
            filterUnits="objectBoundingBox"
            x="-10%" y="-10%" width="110%" height="110%">
        <feGaussianBlur in="SourceAlpha"
                        stdDeviation="4"
                        result="blur"/>
        <feSpecularLighting in="blur"
                            surfaceScale="7"
                            specularConstant="0.6"
                            specularExponent="5"
                            result="spec"
                            lighting-color="#4E7199">
            <fePointLight x="-5000" y="-10000" z="20000"/>
        </feSpecularLighting>
        <feComposite in="spec"
                     in2="SourceAlpha"
                     operator="in"
                     result="spec2"/>
        <feComposite in="SourceGraphic"
                     in2="spec2"
                     operator="arithmetic"
                     k1="0" k2="1" k3="1" k4="0" />
    </filter>
</svg>

</body>
</html>
