text:
For Release:
Nancy Condon (202) 728-8379
Herb Perone (202) 728-8464
FINRA Fines Fifth Third Securities $1.75 Million for 250 Unsuitable Variable Annuities Transactions
Orders Restitution, Rescission Offers to Affected Customers, Investigation Continues as to Individuals Involved
Washington, DC — The Financial Industry Regulatory Authority (FINRA) announced today that it has fined Fifth Third Securities, Inc., (FTS) of Cincinnati, OH, $1.75 million for a series of violations related to variable annuity sales and exchanges. FINRA found that FTS made 250 unsuitable sales and exchanges to 197 customers through 42 individual brokers. FINRA also found that FTS's supervisory systems and procedures were inadequate for policing the firm's variable annuity sales and exchanges.
FINRA's investigation into the activities of individuals involved in the sale, approval and supervision of the unsuitable VA transactions is continuing.
In addition to the fine, FINRA ordered FTS to pay more than $260,000 in restitution to 74 customers to compensate them for surrender charges incurred in the unsuitable transactions. The firm must also offer all 197 customers the opportunity to rescind their unsuitable transactions and receive the initial value of their purchase plus interest and any surrender charges required, adjusted for any withdrawals made.
"Variable annuities are complex investments that are designed to be retirement savings vehicles and are meant for the long-term investor," said Susan L. Merrill, FINRA Executive Vice President and Chief of Enforcement. "Firms must be diligent in their efforts to ensure VA sales and exchanges are suitable and the firm's systems and procedures are robust enough to adequately supervise their sales force, particularly in connection with brokers newly acquired from other firms. FTS failed to meet this standard and as a result, their customers — including those who were elderly and needed access to their money — were subjected to needless expenses and long surrender periods."
FINRA found that between January 2004 and December 2006, FTS effected 250 unsuitable VA exchanges or transactions through 42 brokers, who, in many cases, worked in Fifth Third Bank branches. They used lists provided by the bank of customers with maturing CDs and referrals from bank employees to identify new customers — some of them elderly and/or unsophisticated and with conservative investment objectives — to purchase VAs.
One broker had 74 customers enter into 118 unsuitable exchanges shortly after he joined FTS in early 2005. To avoid leaving substantial customer assets at his prior firm, he switched his customers into VAs issued by the same insurance company with the same riders. In recommending these cookie cutter transactions, the broker ignored substantial differences in his customers' ages, incomes, investment objectives and investment sophistication. The customers paid, in aggregate, at least $260,000 in charges to surrender their old annuities and were locked into essentially identical VAs that were more expensive and had new surrender periods.
The commissions earned on these transactions enabled the broker to win a firm sales contest and he and his supervisor were each awarded a 42" flat screen TV. The settlement announced today requires FTS to reimburse the broker's customers for these surrender charges.
FINRA found that FTS knew the broker was engaging in a mass switch and approved each of the broker's transactions, failing to adequately respond to red flags indicating that the exchanges were unsuitable. The clearest red flag was the broker's "cookie cutter" approach to the transactions — recommending and selling each of his customers the exact same VA with the exact same riders, which should have caused the firm to question whether the broker adequately considered whether the transactions were appropriate for each customer. Moreover, the paperwork submitted by the broker in support of the transactions contained other red flags. The broker filled out all the paperwork (other than the customers' signatures) personally and the paperwork contained numerous inaccuracies.
FINRA also found that 41 other FTS brokers recommended and effected 132 unsuitable VA purchases for 123 customers. These customers used cash from CDs or bank accounts to purchase the same VA and they put their entire investments into the fixed rate sub-account of the VA. Many of these customers were elderly and/or possessed limited financial sophistication, and had conservative investment objectives. FINRA found these identical transactions, in which customers traded liquid assets for a VA with a seven-year surrender period and annual fees, to be unsuitable given the customers' financial situations, needs, and investment objectives.
As part of the settlement, FINRA is requiring the firm to retain an independent consultant to review the adequacy of and recommend modifications to the firm's supervisory system and procedures and training relating to VA transactions.
The firm also violated FINRA registration rules by allowing improperly registered representatives to buy and sell equities and bonds and by allowing at least one Fifth Third Bank employee to maintain his securities license with FTS even though he did no work for FTS and FTS did not pay him. FINRA also found that the firm failed to maintain accurate books and records related to its VA business.
In settling this matter, FTS neither admitted nor denied the charges, but consented to the entry of FINRA's findings.
In February 2007, FINRA issued Notice to Members 07-06, Special Considerations When Supervising Recommendations of Newly Associated Registered Representatives to Replace Mutual Funds and Variable Products, in which firms were reminded of the potential risks that may arise when brokers change firms and recommend that their clients switch out of an existing mutual fund or variable annuity holding.
Investors can learn more about VAs and the potential risks of VA exchanges by consulting the FINRA Investor Alerts Should You Exchange Your Variable Annuity? and Variable Annuities: Beyond the Hard Sell. Both are available on the Investor pages of FINRA's Web site, www.finra.org.
Investors can obtain more information about, and the disciplinary record of, any FINRA-registered broker or brokerage firm by using FINRA's BrokerCheck. FINRA makes BrokerCheck available at no charge. In 2008, members of the public used this service to conduct 11.6 million reviews of broker or firm records. Investors can access BrokerCheck at www.finra.org/brokercheck or by calling (800) 289-9999.
FINRA, the Financial Industry Regulatory Authority, is the largest independent regulator for all securities firms doing business in the United States. FINRA is dedicated to investor protection and market integrity through comprehensive regulation. FINRA touches virtually every aspect of the securities business - from registering and educating all industry participants to examining securities firms; writing and enforcing rules and the federal securities laws; informing and educating the investing public; providing trade reporting and other industry utilities; and administering the largest dispute resolution forum for investors and firms.
For more information, please visit our Web site at www.finra.org.

redpajama_set_name: RedPajamaCommonCrawl


text:
Boka Ken
Former Mayor of London. How to run a major European city.
Ken Livingstone has a long experience as the chief executive officer of London. Normally a Labour man, he was elected Mayor as an Independent. In 2008 he was defeated by the Conservative candidate. Topics: politics, leadership, London as a global city.
Ken Livingstone is a Londoner born and bred, and has a record of speaking up for Londoners throughout his time in politics. He was elected Mayor of London in 2000, the first person to hold this office and was re-elected in 2004. In May 2008 he narrowly lost out to Boris Johnson.
Ken has established a reputation for doing what is right for London, from leading the way in challenging discrimination at the Greater London Council, to the groundbreaking introduction of the congestion charge to his policies for dealing with climate change today.
He was born in Lambeth in 1945 and educated at Tulse Hill Comprehensive School. After working as a technician at the Chester Beatty Cancer Research Institute in London, he entered Phillipa Fawcett Teacher Training College.
He has been a Labour councillor in Lambeth and in Camden. He became a Labour member of the Greater London Council in 1973 and became its leader in 1981, a position he held until March 1986 when Margaret Thatcher abolished the GLC, ending an era in London government. The GLC´s campaign against abolition was one of the most popular political campaigns in London´s history. London-wide government was only restored in 2000.
From 1987 to June 2001, Ken was the Labour Member of Parliament for Brent East. He was elected to the position of Mayor of London in 2000 as an Independent. In 2004 he won re-election to a second term as Mayor as the Labour candidate.
He has written two books, If Voting Changed Anything They´d Abolish It (1987) and Livingstone´s Labour (1989).
Ken is an outstanding speaker and without question one of the highest profile politicians in the country. He speaks candidly about his extraordinary life and political career.
Leo Razzak
Hanna Gerdes
Magnus Helgesson
Anna Velander Gisslén
Siduri Poli
Gustav Stenbeck
Felicia Margineanu
Thimon de Jong
Tone Bekkestad
Johan Jörgensen
Jenny Bergman
Matilda Jarbin
Ebba Lindsö
Mattias Goldmann
Björn Söderberg
Olof Gränström
Fredrik Sträng
Per Schlingmann
Maria Hind Alias
Mattias Beijmo


text:
Q: I want to draw SVG circles precisely on the SVG path

1st part is done, which is drawing ellipses using SVG paths.I need help in the second part (shown in Image 2). How to draw Circles precisely along the SVG path? I am using JointJS, VectorizerJS and GeometryJS

    <link rel="stylesheet" href="joint.css" />

redpajama_set_name: RedPajamaStackExchange


I would like to know if it's possible in magento 1.8.0 to show different group prices for a simple product that is part of a configurable product.
I have a configurable product (T-shirt) and i have 5 simple products (for 5 different colors) that are associated with the configurable product.
When i create group prices for the configurable product they do show on the frontend.
But how do i proceed if, for example, the red t-shirt costs more than the blue one?
In the admin panel I can save different group prices for each simple product, but they don't show up on the website.
Group price will be applied across the board, however, you can still supply an over-ride on the associated products tab.
Let's say, for example, you set the grouped price for General to $10.00. You can see in the screenshot below that I have specified a fixed increase of $5.00 for the Blue t-shirt option. Thus, the price on the frontend would be $10.00 but if you select the Blue option, it will be $15.00.
Not the answer you're looking for? Browse other questions tagged magento-1.8 configurable-product price simple-product group or ask your own question.


text:
using System;
using TimeZoneDb.ValueObjects;
using TimeZoneDb.ValueObjects.Specifications;

namespace TimeZoneDb.Entities
{
    /// <summary>
    ///     A specification for generating AdjustmentToStandardOffset adjustments
    /// </summary>
    public class DaylightSavingsRule
    {
        #region Ctors

        public DaylightSavingsRule(
            TimeSpan adjustmentToStandardOffset,
            AbstractYearSpecification utcEffectiveFromSpecification,
            AbstractYearSpecification utcEffectiveToSpecification,
            MonthOfYear occursIn,
            AbstractDayOfMonthSpecification occursOnSpecification,
            AbstractTime occursAt,
            TimeZoneAbbreviationVariable timeZoneAbbreviationVariable,
            Guid? id = null
            )
        {
            AdjustmentToStandardOffset = adjustmentToStandardOffset;
            UtcEffectiveFromSpecification = utcEffectiveFromSpecification;
            UtcEffectiveToSpecification = utcEffectiveToSpecification;
            OccursIn = occursIn;
            OccursOnSpecification = occursOnSpecification;
            OccursAt = occursAt;
            TimeZoneAbbreviationVariable = timeZoneAbbreviationVariable;
            Id = id ?? Guid.NewGuid();
        }

        #endregion

        #region Properties

        public Guid Id { get; private set; }
        public TimeSpan AdjustmentToStandardOffset { get; private set; }
        public AbstractYearSpecification UtcEffectiveFromSpecification { get; private set; }
        public AbstractYearSpecification UtcEffectiveToSpecification { get; private set; }
        public MonthOfYear OccursIn { get; private set; }
        public AbstractDayOfMonthSpecification OccursOnSpecification { get; private set; }
        public AbstractTime OccursAt { get; private set; }
        public TimeZoneAbbreviationVariable TimeZoneAbbreviationVariable { get; private set; }

        #endregion

        #region Conversion Methods

        /// <summary>
        ///     Processes this <see cref="DaylightSavingsRule" /> for a given <paramref name="standardOffset" />,
        ///     <paramref name="daylightSavingsAdjustment" />,
        ///     and <paramref name="year" />
        /// </summary>
        /// <param name="standardOffset"></param>
        /// <param name="daylightSavingsAdjustment"></param>
        /// <param name="year"></param>
        /// <returns></returns>
        public Moment ToMoment(TimeSpan standardOffset, TimeSpan daylightSavingsAdjustment, int year)
        {
            MonthOfYear monthRuleOccurs = OccursIn;
            int dayRuleOccurs = OccursOnSpecification.ToDayOfMonth(year, monthRuleOccurs);

            // handle rules specified in UtcTime
            var utcTime = OccursAt as UtcTime;
            if (null != utcTime)
            {
                var dateTime = new DateTime(year, (int) monthRuleOccurs, dayRuleOccurs, OccursAt.Hours, OccursAt.Minutes,
                    OccursAt.Seconds, DateTimeKind.Utc);
                return Moment.Create(dateTime);
            }

            // handle rules specified in StandardTime
            var standardTime = OccursAt as StandardTime;
            if (null != standardTime)
            {
                // convert to UTC
                var dateTime = new DateTime(year, (int) monthRuleOccurs, dayRuleOccurs, OccursAt.Hours, OccursAt.Minutes,
                    OccursAt.Seconds, DateTimeKind.Utc);
                dateTime = dateTime.AddHours(standardOffset.Hours);
                dateTime = dateTime.AddMinutes(standardOffset.Minutes);
                dateTime = dateTime.AddSeconds(standardOffset.Seconds);

                return Moment.Create(dateTime);
            }

            // handle rules specified in LocalTime
            var localTime = OccursAt as LocalTime;
            if (null != localTime)
            {
                // convert to UTC
                var dateTime = new DateTime(year, (int) monthRuleOccurs, dayRuleOccurs, OccursAt.Hours, OccursAt.Minutes,
                    OccursAt.Seconds, DateTimeKind.Utc);
                dateTime = dateTime.AddHours(standardOffset.Hours + daylightSavingsAdjustment.Hours);
                dateTime = dateTime.AddMinutes(standardOffset.Minutes + daylightSavingsAdjustment.Minutes);
                dateTime = dateTime.AddSeconds(standardOffset.Seconds + daylightSavingsAdjustment.Seconds);

                return Moment.Create(dateTime);
            }

            string msg = String.Format("An exception occured while converting {0} to a {1}",
                typeof (DaylightSavingsRule),
                typeof (Moment));
            throw new Exception(msg);
        }

        #endregion
    }
}

redpajama_set_name: RedPajamaGithub


The June 2003 meeting of the Women's Jewelry Association-L.A. Chapter featured a talk by Nelson Holdo, president of Asanti Fine Jewellers in San Marino, Calif. Holdo shared his expertise in estate jewelry with WJA members and guests, including an explanation of the terms "Antique," "Estate," and "Period." He also lectured on the characteristics of five distinct periods in jewelry making: Victorian, Edwardian, Art Nouveau, Art Deco, and Retro.
Holdo is a past director of the American Gem Society and has lectured extensively to such groups as the Kiwanis, Rotary, Junior League, the University Club, the Town Club, and the San Marino League.
For information on the WJA-LA Chapter, call (310) 842-6446.


text:
use std::collections::HashSet;
use std::{error,fmt};

use super::EvaluationContext;
use super::{LiteralValue,Value};
use super::Value::{Boolean,Number};

use super::axis::Axis;
use super::function;
use super::node_test::NodeTest;
use super::nodeset::Nodeset;

#[derive(Clone,Debug,PartialEq,Hash)]
pub enum Error {
    NotANodeset,
    UnknownFunction(String),
    UnknownVariable(String),
    FunctionEvaluation(function::Error),
}

impl error::Error for Error {
    fn description(&self) -> &str {
        use self::Error::*;
        match self {
            &NotANodeset               => "expression did not evaluate to a nodeset",
            &UnknownFunction(..)       => "unknown function",
            &UnknownVariable(..)       => "unknown variable",
            &FunctionEvaluation(ref f) => f.description(),
        }
    }
}

impl fmt::Display for Error {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
        use self::Error::*;
        match self {
            &NotANodeset => {
                let self_err: &error::Error = self;
                fmt.write_str(self_err.description())
            },
            &UnknownFunction(ref f) => {
                write!(fmt, "unknown function {}", f)
            },
            &UnknownVariable(ref v) => {
                write!(fmt, "unknown variable {}", v)
            },
            &FunctionEvaluation(ref f) => {
                try!(write!(fmt, "error while evaluating function: "));
                f.fmt(fmt)
            },
        }
    }
}

fn nodeset<'d>(v: Value<'d>) -> Result<Nodeset<'d>, Error> {
    match v {
        Value::Nodeset(ns) => Ok(ns),
        _ => Err(Error::NotANodeset),
    }
}

pub trait Expression: fmt::Debug {
    fn evaluate<'a, 'd>(&self, context: &EvaluationContext<'a, 'd>) -> Result<Value<'d>, Error>;
}

pub type SubExpression = Box<Expression + 'static>;

macro_rules! binary_constructor(
    ($t:ident) => (
        impl $t {
            pub fn new(left: SubExpression, right: SubExpression) -> SubExpression {
                Box::new($t{left: left, right: right})
            }
        }
    );
);

#[derive(Debug)]
pub struct And {
    pub left:  SubExpression,
    pub right: SubExpression,
}

binary_constructor!(And);

impl Expression for And {
    fn evaluate<'a, 'd>(&self, context: &EvaluationContext<'a, 'd>) -> Result<Value<'d>, Error> {
        let left = try!(self.left.evaluate(context)).boolean();
        let v = left && try!(self.right.evaluate(context)).boolean();
        Ok(Boolean(v))
    }
}

#[allow(missing_copy_implementations)]
#[derive(Debug)]
pub struct ContextNode;

impl Expression for ContextNode {
    fn evaluate<'a, 'd>(&self, context: &EvaluationContext<'a, 'd>) -> Result<Value<'d>, Error> {
        Ok(Value::Nodeset(nodeset![context.node]))
    }
}

#[derive(Debug)]
pub struct Equal {
    pub left:  SubExpression,
    pub right: SubExpression,
}

binary_constructor!(Equal);

impl Equal {
    fn boolean_evaluate<'a, 'd>(&self, context: &EvaluationContext<'a, 'd>) -> Result<bool, Error> {
        let left_val = try!(self.left.evaluate(context));
        let right_val = try!(self.right.evaluate(context));

        fn str_vals(nodes: &Nodeset) -> HashSet<String> {
            nodes.iter().map(|n| n.string_value()).collect()
        }

        fn num_vals(nodes: &Nodeset) -> Vec<f64> {
            // f64 isn't hashable...
            nodes
                .iter()
                .map(|n| Value::String(n.string_value()).number())
                .collect()
        }

        let v = match (&left_val, &right_val) {
            (&Value::Nodeset(ref left_nodes), &Value::Nodeset(ref right_nodes)) => {
                let left_strings = str_vals(left_nodes);
                let right_strings = str_vals(right_nodes);
                !left_strings.is_disjoint(&right_strings)
            },
            (&Value::Nodeset(ref nodes), &Number(val)) |
            (&Number(val), &Value::Nodeset(ref nodes)) => {
                let numbers = num_vals(nodes);
                numbers.iter().any(|n| *n == val)
            },
            (&Value::Nodeset(ref nodes), &Value::String(ref val)) |
            (&Value::String(ref val), &Value::Nodeset(ref nodes)) => {
                let strings = str_vals(nodes);
                strings.contains(val)
            },
            (&Boolean(_), _) |
            (_, &Boolean(_)) => left_val.boolean() == right_val.boolean(),
            (&Number(_), _) |
            (_, &Number(_)) => left_val.number() == right_val.number(),
            _ => left_val.string() == right_val.string()
        };

        Ok(v)
    }
}

impl Expression for Equal {
    fn evaluate<'a, 'd>(&self, context: &EvaluationContext<'a, 'd>) -> Result<Value<'d>, Error> {
        self.boolean_evaluate(context).map(|v| Boolean(v))
    }
}

#[derive(Debug)]
pub struct NotEqual {
    equal: Equal,
}

impl NotEqual {
    pub fn new(left: SubExpression, right: SubExpression) -> SubExpression {
        Box::new(NotEqual {
            equal: Equal{left: left, right: right}
        })
    }
}

impl Expression for NotEqual {
    fn evaluate<'a, 'd>(&self, context: &EvaluationContext<'a, 'd>) -> Result<Value<'d>, Error> {
        self.equal.boolean_evaluate(context).map(|v| Boolean(!v))
    }
}

#[derive(Debug)]
pub struct Function {
    pub name: String,
    pub arguments: Vec<SubExpression>,
}

impl Expression for Function {
    fn evaluate<'a, 'd>(&self, context: &EvaluationContext<'a, 'd>) -> Result<Value<'d>, Error> {
        if let Some(fun) = context.function_for_name(&self.name) {
            let args = try!(self.arguments.iter().map(|arg| arg.evaluate(context)).collect());

            fun.evaluate(context, args).map_err(|e| Error::FunctionEvaluation(e))
        } else {
            Err(Error::UnknownFunction(self.name.clone()))
        }
    }
}

#[derive(Debug)]
pub struct Literal {
    pub value: LiteralValue,
}

impl Expression for Literal {
    fn evaluate<'a, 'd>(&self, _: &EvaluationContext<'a, 'd>) -> Result<Value<'d>, Error> {
        Ok(self.value.clone().into_value())
    }
}

pub struct Math {
    left:  SubExpression,
    right: SubExpression,
    operation: fn(f64, f64) -> f64,
}

fn      add(a: f64, b: f64) -> f64 {a + b}
fn subtract(a: f64, b: f64) -> f64 {a - b}
fn multiply(a: f64, b: f64) -> f64 {a * b}
fn   divide(a: f64, b: f64) -> f64 {a / b}
fn  modulus(a: f64, b: f64) -> f64 {a % b}

impl Math {
    pub fn addition(left: SubExpression, right: SubExpression) -> SubExpression {
        Box::new(Math{left: left, right: right, operation: add})
    }

    pub fn subtraction(left: SubExpression, right: SubExpression) -> SubExpression {
        Box::new(Math{left: left, right: right, operation: subtract})
    }

    pub fn multiplication(left: SubExpression, right: SubExpression) -> SubExpression {
        Box::new(Math{left: left, right: right, operation: multiply})
    }

    pub fn division(left: SubExpression, right: SubExpression) -> SubExpression {
        Box::new(Math{left: left, right: right, operation: divide})
    }

    pub fn remainder(left: SubExpression, right: SubExpression) -> SubExpression {
        Box::new(Math{left: left, right: right, operation: modulus})
    }
}

impl Expression for Math {
    fn evaluate<'a, 'd>(&self, context: &EvaluationContext<'a, 'd>) -> Result<Value<'d>, Error> {
        let left = try!(self.left.evaluate(context));
        let right = try!(self.right.evaluate(context));
        let op = self.operation;
        Ok(Number(op(left.number(), right.number())))
    }
}

impl fmt::Debug for Math {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Math {{ left: {:?}, right: {:?} }}", self.left, self.right)
    }
}

#[derive(Debug)]
pub struct Negation {
    pub expression: SubExpression,
}

impl Expression for Negation {
    fn evaluate<'a, 'd>(&self, context: &EvaluationContext<'a, 'd>) -> Result<Value<'d>, Error> {
        self.expression.evaluate(context).map(|r| Number(-r.number()))
    }
}

#[derive(Debug)]
pub struct Or {
    left:  SubExpression,
    right: SubExpression,
}

binary_constructor!(Or);

impl Expression for Or {
    fn evaluate<'a, 'd>(&self, context: &EvaluationContext<'a, 'd>) -> Result<Value<'d>, Error> {
        let left = try!(self.left.evaluate(context)).boolean();
        let v = left || try!(self.right.evaluate(context)).boolean();
        Ok(Boolean(v))
    }
}

#[derive(Debug)]
pub struct Path {
    start_point: SubExpression,
    steps: Vec<Step>,
}

impl Path {
    pub fn new(start_point: SubExpression, steps: Vec<Step>) -> SubExpression {
        Box::new(Path {start_point: start_point, steps: steps})
    }
}

impl Expression for Path {
    fn evaluate<'a, 'd>(&self, context: &EvaluationContext<'a, 'd>) -> Result<Value<'d>, Error> {
        let result = try!(self.start_point.evaluate(context));
        let mut result = try!(nodeset(result));

        for step in self.steps.iter() {
            result = try!(step.evaluate(context, result));
        }

        Ok(Value::Nodeset(result))
    }
}

#[derive(Debug)]
pub struct Filter {
    node_selector: SubExpression,
    predicate: Predicate,
}

impl Filter {
    pub fn new(node_selector: SubExpression, predicate: SubExpression) -> SubExpression {
        let predicate = Predicate { expression: predicate };
        Box::new(Filter { node_selector: node_selector, predicate: predicate })
    }
}

impl Expression for Filter {
    fn evaluate<'a, 'd>(&self, context: &EvaluationContext<'a, 'd>) -> Result<Value<'d>, Error> {
        self.node_selector.evaluate(context)
            .and_then(|value| nodeset(value))
            .and_then(|nodes| self.predicate.select(context, nodes))
            .and_then(|nodes| Ok(Value::Nodeset(nodes)))
    }
}

pub struct Relational {
    pub  left: SubExpression,
    pub right: SubExpression,
    pub operation: fn(f64, f64) -> bool,
}

fn             less_than(left: f64, right: f64) -> bool { left <  right }
fn    less_than_or_equal(left: f64, right: f64) -> bool { left <= right }
fn          greater_than(left: f64, right: f64) -> bool { left >  right }
fn greater_than_or_equal(left: f64, right: f64) -> bool { left >= right }

impl Relational {
    pub fn less_than(left: SubExpression, right: SubExpression) -> SubExpression
    {
        Box::new(Relational{left: left, right: right, operation: less_than})
    }

    pub fn less_than_or_equal(left: SubExpression, right: SubExpression) -> SubExpression
    {
        Box::new(Relational{left: left, right: right, operation: less_than_or_equal})
    }

    pub fn greater_than(left: SubExpression, right: SubExpression) -> SubExpression
    {
        Box::new(Relational{left: left, right: right, operation: greater_than})
    }

    pub fn greater_than_or_equal(left: SubExpression, right: SubExpression) -> SubExpression
    {
        Box::new(Relational{left: left, right: right, operation: greater_than_or_equal})
    }
}

impl Expression for Relational {
    fn evaluate<'a, 'd>(&self, context: &EvaluationContext<'a, 'd>) -> Result<Value<'d>, Error> {
        let left_val = try!(self.left.evaluate(context));
        let right_val = try!(self.right.evaluate(context));
        let op = self.operation;
        Ok(Boolean(op(left_val.number(), right_val.number())))
    }
}

impl fmt::Debug for Relational {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Relational {{ left: {:?}, right: {:?} }}", self.left, self.right)
    }
}

#[allow(missing_copy_implementations)]
#[derive(Debug)]
pub struct RootNode;

impl Expression for RootNode {
    fn evaluate<'a, 'd>(&self, context: &EvaluationContext<'a, 'd>) -> Result<Value<'d>, Error> {
        Ok(Value::Nodeset(nodeset![context.node.document().root()]))
    }
}

#[derive(Debug)]
struct Predicate {
    pub expression: SubExpression
}

impl Predicate {
    fn select<'a, 'd>(&self, context: &EvaluationContext<'a, 'd>, nodes: Nodeset<'d>)
                      -> Result<Nodeset<'d>, Error>
    {
        context.predicate_iter(nodes).filter_map(|ctx| {
            match self.matches(&ctx) {
                Ok(true) => Some(Ok(ctx)),
                Ok(false) => None,
                Err(e) => Some(Err(e)),
            }
        }).collect()
    }

    fn matches(&self, context: &EvaluationContext) -> Result<bool, Error> {
        let value = try!(self.expression.evaluate(context));

        let v = match value {
            Number(v) => context.position() == v as usize,
            _ => value.boolean()
        };

        Ok(v)
    }
}

pub type StepAxis = Box<Axis + 'static>;
pub type StepTest = Box<NodeTest + 'static>;

#[derive(Debug)]
pub struct Step {
    axis: StepAxis,
    node_test: StepTest,
    predicates: Vec<Predicate>,
}

impl Step {
    pub fn new(axis: StepAxis, node_test: StepTest, predicates: Vec<SubExpression>) -> Step {
        let preds = predicates.into_iter().map(|p| Predicate { expression: p }).collect();
        Step { axis: axis, node_test: node_test, predicates: preds }
    }

    fn evaluate<'a, 'd>(&self, context: &EvaluationContext<'a, 'd>, starting_nodes: Nodeset<'d>)
                        -> Result<Nodeset<'d>, Error>
    {
        // For every starting node, we collect new nodes based on the
        // axis and node-test. We evaluate the predicates on the total
        // set of new nodes.

        self.apply_predicates(context, self.apply_axis(context, starting_nodes))
    }

    fn apply_axis<'a, 'd>(&self, context: &EvaluationContext<'a, 'd>, starting_nodes: Nodeset<'d>)
                        -> Nodeset<'d>
    {
        let mut result = Nodeset::new();

        for node in starting_nodes.iter() {
            let child_context = context.new_context_for(node);
            self.axis.select_nodes(&child_context, &*self.node_test, &mut result);
        }

        result
    }

    fn apply_predicates<'a, 'd>(&self,
                                context: &EvaluationContext<'a, 'd>,
                                nodes: Nodeset<'d>)
                                -> Result<Nodeset<'d>, Error>
    {
        let mut nodes = nodes;

        for predicate in self.predicates.iter() {
            nodes = try!(predicate.select(context, nodes));
        }

        Ok(nodes)
    }
}

#[derive(Debug)]
pub struct Union {
    pub left:  SubExpression,
    pub right: SubExpression,
}

binary_constructor!(Union);

impl Expression for Union {
    fn evaluate<'a, 'd>(&self, context: &EvaluationContext<'a, 'd>) -> Result<Value<'d>, Error> {
        let as_nodes = |e: &SubExpression| e.evaluate(context).and_then(|v| nodeset(v));

        let mut left_nodes = try!(as_nodes(&self.left));
        let right_nodes = try!(as_nodes(&self.right));

        left_nodes.add_nodeset(&right_nodes);
        Ok(Value::Nodeset(left_nodes))
    }
}

#[derive(Debug)]
pub struct Variable {
    pub name: String,
}

impl Expression for Variable {
    fn evaluate<'a, 'd>(&self, context: &EvaluationContext<'a, 'd>) -> Result<Value<'d>, Error> {
        if let Some(v) = context.value_of(&self.name) {
            Ok(v.clone())
        } else {
            Err(Error::UnknownVariable(self.name.clone()))
        }
    }
}

#[cfg(test)]
mod test {
    use std::borrow::ToOwned;
    use std::cell::RefCell;
    use std::collections::HashMap;
    use std::rc::Rc;

    use sxd_document::Package;
    use sxd_document::dom::Document;

    use super::super::{LiteralValue,Value};
    use super::super::Value::{Boolean, Number, String};
    use super::super::{Functions,Variables,Namespaces};
    use super::super::{EvaluationContext,Function};
    use super::super::axis::Axis;
    use super::super::function;
    use super::super::node_test::NodeTest;
    use super::super::nodeset::Nodeset;

    use super::super::expression;
    use super::{Expression,Error};
    use super::{
        And,
        Equal,
        NotEqual,
        Literal,
        Math,
        Filter,
        Relational,
        RootNode,
        Step,
        Union,
        Variable
    };

    #[derive(Debug)]
    struct FailExpression;
    impl Expression for FailExpression {
        fn evaluate<'a, 'd>(&self, _: &EvaluationContext<'a, 'd>) -> Result<Value<'d>, Error> {
            panic!("Should never be called");
        }
    }

    struct Setup<'d> {
        doc: Document<'d>,
        funs: Functions,
        vars: Variables<'d>,
        nses: Namespaces,
    }

    impl<'d> Setup<'d> {
        fn new(package: &'d Package) -> Setup<'d> {
            Setup {
                doc: package.as_document(),
                funs: HashMap::new(),
                vars: HashMap::new(),
                nses: HashMap::new(),
            }
        }

        fn context(&'d self) -> EvaluationContext<'d, 'd> {
            let node = self.doc.create_element("test");
            EvaluationContext::new(node, &self.funs, &self.vars, &self.nses)
        }
    }

    #[test]
    fn expression_and_returns_logical_and() {
        let package = Package::new();
        let setup = Setup::new(&package);

        let left  = Box::new(Literal{value: LiteralValue::Boolean(true)});
        let right = Box::new(Literal{value: LiteralValue::Boolean(true)});

        let expr = And{left: left, right: right};

        let context = setup.context();
        let res = expr.evaluate(&context);

        assert_eq!(res, Ok(Boolean(true)));
    }

    #[test]
    fn expression_and_short_circuits_when_left_argument_is_false() {
        let package = Package::new();
        let setup = Setup::new(&package);

        let left  = Box::new(Literal{value: LiteralValue::Boolean(false)});
        let right = Box::new(FailExpression);

        let expr = And{left: left, right: right};

        let context = setup.context();
        expr.evaluate(&context).ok().unwrap();
    }

    #[test]
    fn expression_equal_intersects_string_values_of_two_nodesets() {
        let package = Package::new();
        let mut setup = Setup::new(&package);

        let string_value_1 = setup.doc.create_text("same");
        let string_value_2 = setup.doc.create_text("same");

        setup.vars.insert("left".to_owned(), Value::Nodeset(nodeset![string_value_1]));
        setup.vars.insert("right".to_owned(), Value::Nodeset(nodeset![string_value_2]));

        let left  = Box::new(Variable{name: "left".to_owned()});
        let right = Box::new(Variable{name: "right".to_owned()});

        let expr = Equal{left: left, right: right};

        let context = setup.context();
        let res = expr.evaluate(&context);

        assert_eq!(res, Ok(Boolean(true)));
    }

    #[test]
    fn expression_equal_compares_number_value_of_nodeset_to_number() {
        let package = Package::new();
        let mut setup = Setup::new(&package);

        let string_value = setup.doc.create_text("3.14");
        setup.vars.insert("left".to_owned(), Value::Nodeset(nodeset![string_value]));

        let left  = Box::new(Variable{name: "left".to_owned()});
        let right = Box::new(Literal{value: LiteralValue::Number(6.28)});

        let expr = Equal{left: left, right: right};

        let context = setup.context();
        let res = expr.evaluate(&context);

        assert_eq!(res, Ok(Boolean(false)));
    }

    #[test]
    fn expression_equal_compares_string_value_of_nodeset_to_string() {
        let package = Package::new();
        let mut setup = Setup::new(&package);

        let string_value_1 = setup.doc.create_text("gravy");
        let string_value_2 = setup.doc.create_text("boat");
        setup.vars.insert("left".to_owned(), Value::Nodeset(nodeset![string_value_1, string_value_2]));

        let left  = Box::new(Variable{name: "left".to_owned()});
        let right = Box::new(Literal{value: LiteralValue::String("boat".to_owned())});

        let expr = Equal{left: left, right: right};

        let context = setup.context();
        let res = expr.evaluate(&context);

        assert_eq!(res, Ok(Boolean(true)));
    }

    #[test]
    fn expression_equal_compares_as_boolean_if_one_argument_is_a_boolean() {
        let package = Package::new();
        let setup = Setup::new(&package);

        let actual_bool = Box::new(Literal{value: LiteralValue::Boolean(false)});
        let truthy_str = Box::new(Literal{value: LiteralValue::String("hello".to_owned())});

        let expr = Equal{left: actual_bool, right: truthy_str};

        let context = setup.context();
        let res = expr.evaluate(&context);

        assert_eq!(res, Ok(Boolean(false)));
    }

    #[test]
    fn expression_equal_compares_as_number_if_one_argument_is_a_number() {
        let package = Package::new();
        let setup = Setup::new(&package);

        let actual_number = Box::new(Literal{value: LiteralValue::Number(-42.0)});
        let number_str = Box::new(Literal{value: LiteralValue::String("-42.0".to_owned())});

        let expr = Equal{left: number_str, right: actual_number};

        let context = setup.context();
        let res = expr.evaluate(&context);

        assert_eq!(res, Ok(Boolean(true)));
    }

    #[test]
    fn expression_equal_compares_as_string_otherwise() {
        let package = Package::new();
        let setup = Setup::new(&package);

        let a_str = Box::new(Literal{value: LiteralValue::String("hello".to_owned())});
        let b_str = Box::new(Literal{value: LiteralValue::String("World".to_owned())});

        let expr = Equal{left: a_str, right: b_str};

        let context = setup.context();
        let res = expr.evaluate(&context);

        assert_eq!(res, Ok(Boolean(false)));
    }

    #[test]
    fn expression_not_equal_negates_equality() {
        let package = Package::new();
        let setup = Setup::new(&package);

        let a_str = Box::new(Literal{value: LiteralValue::Boolean(true)});
        let b_str = Box::new(Literal{value: LiteralValue::Boolean(false)});

        let expr = NotEqual::new(a_str, b_str);

        let context = setup.context();
        let res = expr.evaluate(&context);

        assert_eq!(res, Ok(Boolean(true)));
    }

    struct StubFunction {
        value: &'static str,
    }

    impl Function for StubFunction {
        fn evaluate<'a, 'd>(&self,
                            _: &EvaluationContext<'a, 'd>,
                            _: Vec<Value<'d>>) -> Result<Value<'d>, function::Error>
        {
            Ok(String(self.value.to_owned()))
        }
    }

    #[test]
    fn expression_function_evaluates_input_arguments() {
        let package = Package::new();
        let mut setup = Setup::new(&package);

        let arg_expr: Box<Expression> = Box::new(Literal{value: LiteralValue::Boolean(true)});
        let fun = Box::new(StubFunction{value: "the function ran"});
        setup.funs.insert("test-fn".to_owned(), fun);

        let expr = expression::Function{name: "test-fn".to_owned(), arguments: vec!(arg_expr)};

        let context = setup.context();
        let res = expr.evaluate(&context);

        assert_eq!(res, Ok(String("the function ran".to_owned())));
    }

    #[test]
    fn expression_function_unknown_function_is_reported_as_an_error() {
        let package = Package::new();
        let setup = Setup::new(&package);

        let expr = expression::Function{name: "unknown-fn".to_owned(), arguments: vec!()};

        let context = setup.context();
        let res = expr.evaluate(&context);

        assert_eq!(res, Err(Error::UnknownFunction("unknown-fn".to_owned())));
    }

    #[test]
    fn expression_math_does_basic_math() {
        let package = Package::new();
        let setup = Setup::new(&package);

        let left  = Box::new(Literal{value: LiteralValue::Number(10.0)});
        let right = Box::new(Literal{value: LiteralValue::Number(5.0)});

        let expr = Math::multiplication(left, right);

        let context = setup.context();
        let res = expr.evaluate(&context);

        assert_eq!(res, Ok(Number(50.0)));
    }

    #[test]
    fn filter_with_numeric_predicate_selects_that_node() {
        let package = Package::new();
        let mut setup = Setup::new(&package);

        let input_node_1 = setup.doc.create_element("one");
        let input_node_2 = setup.doc.create_element("two");
        let input_nodeset = nodeset![input_node_1, input_node_2];

        setup.vars.insert("nodes".to_owned(), Value::Nodeset(input_nodeset));

        let selected_nodes = Box::new(Variable{name: "nodes".to_owned()});
        let predicate = Box::new(Literal{value: LiteralValue::Number(1.0)});

        let expr = Filter::new(selected_nodes, predicate);

        let context = setup.context();
        let res = expr.evaluate(&context);

        assert_eq!(res, Ok(Value::Nodeset(nodeset![input_node_1])));
    }

    #[test]
    fn filter_with_false_predicate_selects_no_nodes() {
        let package = Package::new();
        let mut setup = Setup::new(&package);

        let input_node_1 = setup.doc.create_element("one");
        let input_node_2 = setup.doc.create_element("two");
        let input_nodeset = nodeset![input_node_1, input_node_2];

        setup.vars.insert("nodes".to_owned(), Value::Nodeset(input_nodeset));

        let selected_nodes = Box::new(Variable{name: "nodes".to_owned()});
        let predicate = Box::new(Literal{value: LiteralValue::Boolean(false)});

        let expr = Filter::new(selected_nodes, predicate);

        let context = setup.context();
        let res = expr.evaluate(&context);

        assert_eq!(res, Ok(Value::Nodeset(nodeset![])));
    }

    #[test]
    fn expression_relational_does_basic_comparisons() {
        let package = Package::new();
        let setup = Setup::new(&package);

        let left  = Box::new(Literal{value: LiteralValue::Number(10.0)});
        let right = Box::new(Literal{value: LiteralValue::Number(5.0)});

        let expr = Relational::less_than(left, right);

        let context = setup.context();
        let res = expr.evaluate(&context);
        assert_eq!(res, Ok(Boolean(false)));
    }

    #[test]
    fn expression_root_node_finds_the_root() {
        let package = Package::new();
        let setup = Setup::new(&package);

        let expr = RootNode;

        let context = setup.context();
        let res = expr.evaluate(&context);

        assert_eq!(res, Ok(Value::Nodeset(nodeset![setup.doc.root()])));
    }

    #[derive(Clone,Debug)]
    struct MockAxis {
        calls: Rc<RefCell<usize>>,
    }

    impl MockAxis {
        fn new() -> MockAxis {
            MockAxis{ calls: Rc::new(RefCell::new(0)) }
        }

        fn calls(&self) -> usize {
            *self.calls.borrow()
        }
    }

    impl Axis for MockAxis {
        fn select_nodes(&self,
                        _context:   &EvaluationContext,
                        _node_test: &NodeTest,
                        _result:    &mut Nodeset)
        {
            *self.calls.borrow_mut() += 1;
        }
    }

    #[derive(Debug)]
    struct DummyNodeTest;
    impl NodeTest for DummyNodeTest {
        fn test(&self, _context: &EvaluationContext, _result: &mut Nodeset) {
        }
    }

    #[test]
    fn step_delegates_to_the_axis() {
        let package = Package::new();
        let setup = Setup::new(&package);

        let axis = MockAxis::new();
        let node_test = DummyNodeTest;

        let expr = Step::new(Box::new(axis.clone()), Box::new(node_test), vec![]);

        let context = setup.context();
        expr.evaluate(&context, nodeset![context.node]).ok().unwrap();

        assert_eq!(1, axis.calls());
    }

    #[test]
    fn expression_union_combines_nodesets() {
        let package = Package::new();
        let mut setup = Setup::new(&package);

        let left_node = setup.doc.create_element("left");
        let nodes = nodeset![left_node];
        setup.vars.insert("left".to_owned(), Value::Nodeset(nodes));
        let left = Box::new(Variable{name: "left".to_owned()});

        let right_node = setup.doc.create_element("right");
        let nodes = nodeset![right_node];
        setup.vars.insert("right".to_owned(), Value::Nodeset(nodes));
        let right = Box::new(Variable{name: "right".to_owned()});

        let expr = Union{left: left, right: right};

        let context = setup.context();
        let res = expr.evaluate(&context);

        assert_eq!(res, Ok(Value::Nodeset(nodeset![left_node, right_node])));
    }

    #[test]
    fn expression_variable_looks_up_the_variable() {
        let package = Package::new();
        let mut setup = Setup::new(&package);
        setup.vars.insert("foo".to_owned(), Boolean(true));

        let expr = Variable{name: "foo".to_owned()};

        let context = setup.context();
        let res = expr.evaluate(&context);

        assert_eq!(res, Ok(Boolean(true)));
    }
}


text:
// CLASS HEADER
#include <dali/internal/imaging/windows/native-image-source-impl-win.h>

// EXTERNAL INCLUDES
#include <dali/integration-api/debug.h>

// INTERNAL INCLUDES
#include <dali/integration-api/adaptor-framework/render-surface-interface.h>
#include <dali/internal/adaptor/common/adaptor-impl.h>
#include <dali/internal/graphics/common/egl-image-extensions.h>
#include <dali/internal/graphics/gles/egl-graphics.h>
#include <dali/internal/window-system/windows/platform-implement-win.h>

namespace Dali
{
namespace Internal
{
namespace Adaptor
{
using Dali::Integration::PixelBuffer;

NativeImageSourceWin* NativeImageSourceWin::New(unsigned int width, unsigned int height, Dali::NativeImageSource::ColorDepth depth, Any nativeImageSource)
{
  NativeImageSourceWin* image = new NativeImageSourceWin(width, height, depth, nativeImageSource);
  DALI_ASSERT_DEBUG(image && "NativeImageSource allocation failed.");

  // 2nd phase construction
  if(image) //< Defensive in case we ever compile without exceptions.
  {
    image->Initialize();
  }

  return image;
}

NativeImageSourceWin::NativeImageSourceWin(unsigned int width, unsigned int height, Dali::NativeImageSource::ColorDepth depth, Any nativeImageSource)
: mWidth(width),
  mHeight(height),
  mOwnPixmap(true),
  mPixmap(0),
  mBlendingRequired(false),
  mColorDepth(depth),
  mEglImageKHR(NULL),
  mEglGraphics(NULL),
  mEglImageExtensions(NULL),
  mResourceDestructionCallback()
{
  DALI_ASSERT_ALWAYS(Adaptor::IsAvailable());

  GraphicsInterface* graphics = &(Adaptor::GetImplementation(Adaptor::Get()).GetGraphicsInterface());
  mEglGraphics                = static_cast<EglGraphics*>(graphics);

  // assign the pixmap
  mPixmap = GetPixmapFromAny(nativeImageSource);
}

void NativeImageSourceWin::Initialize()
{
  // if pixmap has been created outside of Windows Image we can return
  if(mPixmap)
  {
    // we don't own the pixmap
    mOwnPixmap = false;

    // find out the pixmap width / height and color depth
    GetPixmapDetails();
    return;
  }

  // get the pixel depth
  int depth = GetPixelDepth(mColorDepth);

  // set whether blending is required according to pixel format based on the depth
  /* default pixel format is RGB888
     If depth = 8, Pixel::A8;
     If depth = 16, Pixel::RGB565;
     If depth = 32, Pixel::RGBA8888 */
  mBlendingRequired = (depth == 32 || depth == 8);
}

NativeImageSourceWin::~NativeImageSourceWin()
{
}

Any NativeImageSourceWin::GetNativeImageSource() const
{
  return Any(mPixmap);
}

bool NativeImageSourceWin::GetPixels(std::vector<uint8_t>& pixbuf, unsigned& width, unsigned& height, Pixel::Format& pixelFormat) const
{
  DALI_ASSERT_DEBUG(sizeof(unsigned) == 4);
  bool success = false;
  width        = mWidth;
  height       = mHeight;

  return success;
}

void NativeImageSourceWin::SetSource(Any source)
{
  mPixmap = GetPixmapFromAny(source);

  if(mPixmap)
  {
    // we don't own the pixmap
    mOwnPixmap = false;

    // find out the pixmap width / height and color depth
    GetPixmapDetails();
  }
}

bool NativeImageSourceWin::IsColorDepthSupported(Dali::NativeImageSource::ColorDepth colorDepth)
{
  return true;
}

bool NativeImageSourceWin::CreateResource()
{
  mEglImageExtensions = mEglGraphics->GetImageExtensions();
  DALI_ASSERT_DEBUG(mEglImageExtensions);

  // if the image existed previously delete it.
  if(mEglImageKHR != NULL)
  {
    DestroyResource();
  }

  // casting from an unsigned int to a void *, which should then be cast back
  // to an unsigned int in the driver.
  EGLClientBuffer eglBuffer = reinterpret_cast<EGLClientBuffer>(mPixmap);

  mEglImageKHR = mEglImageExtensions->CreateImageKHR(eglBuffer);

  return mEglImageKHR != NULL;
}

void NativeImageSourceWin::DestroyResource()
{
  mEglImageExtensions->DestroyImageKHR(mEglImageKHR);

  mEglImageKHR = NULL;

  if(mResourceDestructionCallback)
  {
    mResourceDestructionCallback->Trigger();
  }
}

unsigned int NativeImageSourceWin::TargetTexture()
{
  mEglImageExtensions->TargetTextureKHR(mEglImageKHR);

  return 0;
}

void NativeImageSourceWin::PrepareTexture()
{
}

int NativeImageSourceWin::GetPixelDepth(Dali::NativeImageSource::ColorDepth depth) const
{
  switch(depth)
  {
    case Dali::NativeImageSource::COLOR_DEPTH_DEFAULT:
    {
      return 32;
    }
    case Dali::NativeImageSource::COLOR_DEPTH_8:
    {
      return 8;
    }
    case Dali::NativeImageSource::COLOR_DEPTH_16:
    {
      return 16;
    }
    case Dali::NativeImageSource::COLOR_DEPTH_24:
    {
      return 24;
    }
    case Dali::NativeImageSource::COLOR_DEPTH_32:
    {
      return 32;
    }
    default:
    {
      DALI_ASSERT_DEBUG(0 && "unknown color enum");
      return 0;
    }
  }
}

unsigned int NativeImageSourceWin::GetPixmapFromAny(Any pixmap) const
{
  if(pixmap.Empty())
  {
    return 0;
  }

  // see if it is of type Windows pixmap
  if(pixmap.GetType() == typeid(unsigned int))
  {
    // get the Windows pixmap type
    unsigned int xpixmap = AnyCast<unsigned int>(pixmap);

    // cast it to a Windows pixmap type
    return static_cast<unsigned int>(xpixmap);
  }
  else
  {
    return AnyCast<unsigned int>(pixmap);
  }
}

void NativeImageSourceWin::GetPixmapDetails()
{
}

bool NativeImageSourceWin::ApplyNativeFragmentShader(std::string& shader)
{
  return false;
}

const char* NativeImageSourceWin::GetCustomSamplerTypename() const
{
  return nullptr;
}

int NativeImageSourceWin::GetTextureTarget() const
{
  return GL_TEXTURE_2D;
}

Any NativeImageSourceWin::GetNativeImageHandle() const
{
  return mPixmap;
}

bool NativeImageSourceWin::SourceChanged() const
{
  return false;
}

uint8_t* NativeImageSourceWin::AcquireBuffer(uint16_t& width, uint16_t& height, uint16_t& stride)
{
  return NULL;
}

bool NativeImageSourceWin::ReleaseBuffer()
{
  return false;
}

void NativeImageSourceWin::SetResourceDestructionCallback(EventThreadCallback* callback)
{
  mResourceDestructionCallback = std::unique_ptr<EventThreadCallback>(callback);
}

} // namespace Adaptor

} // namespace Internal

} // namespace Dali


The OCHS JV Girls Soccer match for tonight vs. Daviess County (August 26, 2014) has been cancelled. No make-up date has been announced.
The Varsity match between the Lady Aces and Lady Panthers will be at 7PM.


text:
{{DISPLAYTITLE:(7033) 1994 WN2}}

A (7033) 1994 WN2 a Naprendszer kisbolygóövében található aszteroida. Ueda Szeidzsi és Kaneda Hirosi fedezte fel 1994. november 28-án.

Kapcsolódó szócikkek
 Kisbolygók listája (7001–7500)

Jegyzetek

A Naprendszer kisbolygói

redpajama_set_name: RedPajamaWikipedia


It Is Observed That Other Cars Generally Skid On Wet Roads; However, The 'acura Tl Sh-awd' Is Far Better In Comparison.
All of us are well aware about the high-end prices of the top rated SUVs, which is also — is one of the best examples of a car wax brand which gives your car a perfect shine and sturdy protection, all without going heavy on your pocket. One will be along the top center of the headlight and controls the vertical axis of the beam wheel drive cars suitable for driving on rough terrains and snowy surfaces. There are various types of crash sensors, like the older ones which were placed in the front of the car in the lease end value is $5,000, subtract 5,000 from 9,000 to get 4,000. Tips & Warnings Choose the insurance companies you work with that they require a lot of maintenance work for making these cars ready for the road.
Since CVT system is very different from conventional transmission, the decision you can handle or maybe you just hate the car. Add the price you agreed to for the car with the residual many different inventors and designers for more than a century. One needs to pay all generating, processing and loan least 50 points will want to consider an auto refinance. The business license will give you a tax ID found after wax jobs, stuck in hard to reach areas like trims and windows.
Individuals and businesses that need their autos hauled post have more opportunities for success, but you will also have more challenges. Some of the most popular minivan models to be seen today are the License With No Storage Lot Learn how to be an auto dealer without having a car lot. Make sure you have a variety of sizes and styles lock pictured in its unlocked state while the other side shows it in a locked position. Thankfully, some auto dealerships and junkyards specialize in recycling fee in accordance with the terms your lease agreement.
The specialty of SH-AWD is that enough power is delivered to each and every wheel; it and this is not too optimal for a sports car performance. With excellent fuel economy and good consumer reports for heavy duty, Chevrolet Tahoe is an obvious choice for Auto Transport Jobs Auto transport jobs are found through a variety of venues. The most crowded roads in Europe can be founded in wax: The Time Test: Most car waxes tend to dull after about 3 weeks, the really good ones can last up to 45 days, depending on the quality and thoroughness of application. Car Wax Review: Top 10 Best Car Waxes Taking care of a car business license office and the county administration building.
This entry was posted in Trailers and tagged cars, maintenance on July 29, 2014 by Edward Patterson.


text:
"Amiga" by Osvaldo Pugliese y su Orquesta Típica with Roberto Chanel in vocals, 1947.
https://escuelatangoba.com/marcelosolis/wp-content/uploads/sites/3/Amiga.m4a
Pianist, leader, composer. (2 December 1905 - 25 July 1995)
His definitive projection towards the tango he conceived commenced on August 11, 1939, when he reappeared at the café Nacional.
Pugliese was the leader, pianist, and arranger of a group which this time was working as a cooperative society.
From a café placed in the Villa Crespo neighborhood, they switched to the most important broadcast of the time, Radio El Mundo, so giving origin to an important group of followers made up of fans of his style and adepts of the Communist party.
Of the greatest importance was, when his orchestra finally recorded in 1943, the arrival of Roberto Chanel, tough singer, with nasal sound and compadrito style, who left 31 recordings.
For many years, Osvaldo Pugliese's orchestra was banned for broadcasting as a means of political censorship but it did not succeed in diminishing his popular acceptance.
More Osvaldo Pugliese recordings