text:
/* $OpenBSD: match.c,v 1.27 2008/06/10 23:06:19 djm Exp $ */
/*
 * Author: Tatu Ylonen <ylo@cs.hut.fi>
 * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
 *                    All rights reserved
 * Simple pattern matching, with '*' and '?' as wildcards.
 *
 * As far as I am concerned, the code I have written for this software
 * can be used freely for any purpose.  Any derived versions of this
 * software must be clearly marked as such, and if the derived work is
 * incompatible with the protocol description in the RFC file, it must be
 * called by a name other than "ssh" or "Secure Shell".
 */
/*
 * Copyright (c) 2000 Markus Friedl.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "includes.h"

#include <sys/types.h>

#include <ctype.h>
#include <string.h>

#include "xmalloc.h"
#include "match.h"

/*
 * Returns true if the given string matches the pattern (which may contain ?
 * and * as wildcards), and zero if it does not match.
 */

int
match_pattern(const char *s, const char *pattern)
{
	for (;;) {
		/* If at end of pattern, accept if also at end of string. */
		if (!*pattern)
			return !*s;

		if (*pattern == '*') {
			/* Skip the asterisk. */
			pattern++;

			/* If at end of pattern, accept immediately. */
			if (!*pattern)
				return 1;

			/* If next character in pattern is known, optimize. */
			if (*pattern != '?' && *pattern != '*') {
				/*
				 * Look instances of the next character in
				 * pattern, and try to match starting from
				 * those.
				 */
				for (; *s; s++)
					if (*s == *pattern &&
					    match_pattern(s + 1, pattern + 1))
						return 1;
				/* Failed. */
				return 0;
			}
			/*
			 * Move ahead one character at a time and try to
			 * match at each position.
			 */
			for (; *s; s++)
				if (match_pattern(s, pattern))
					return 1;
			/* Failed. */
			return 0;
		}
		/*
		 * There must be at least one more character in the string.
		 * If we are at the end, fail.
		 */
		if (!*s)
			return 0;

		/* Check if the next character of the string is acceptable. */
		if (*pattern != '?' && *pattern != *s)
			return 0;

		/* Move to the next character, both in string and in pattern. */
		s++;
		pattern++;
	}
	/* NOTREACHED */
}

/*
 * Tries to match the string against the
 * comma-separated sequence of subpatterns (each possibly preceded by ! to
 * indicate negation).  Returns -1 if negation matches, 1 if there is
 * a positive match, 0 if there is no match at all.
 */

int
match_pattern_list(const char *string, const char *pattern, u_int len,
    int dolower)
{
	char sub[1024];
	int negated;
	int got_positive;
	u_int i, subi;

	got_positive = 0;
	for (i = 0; i < len;) {
		/* Check if the subpattern is negated. */
		if (pattern[i] == '!') {
			negated = 1;
			i++;
		} else
			negated = 0;

		/*
		 * Extract the subpattern up to a comma or end.  Convert the
		 * subpattern to lowercase.
		 */
		for (subi = 0;
		    i < len && subi < sizeof(sub) - 1 && pattern[i] != ',';
		    subi++, i++)
			sub[subi] = dolower && isupper(pattern[i]) ?
			    (char)tolower(pattern[i]) : pattern[i];
		/* If subpattern too long, return failure (no match). */
		if (subi >= sizeof(sub) - 1)
			return 0;

		/* If the subpattern was terminated by a comma, skip the comma. */
		if (i < len && pattern[i] == ',')
			i++;

		/* Null-terminate the subpattern. */
		sub[subi] = '\0';

		/* Try to match the subpattern against the string. */
		if (match_pattern(string, sub)) {
			if (negated)
				return -1;		/* Negative */
			else
				got_positive = 1;	/* Positive */
		}
	}

	/*
	 * Return success if got a positive match.  If there was a negative
	 * match, we have already returned -1 and never get here.
	 */
	return got_positive;
}

/*
 * Tries to match the host name (which must be in all lowercase) against the
 * comma-separated sequence of subpatterns (each possibly preceded by ! to
 * indicate negation).  Returns -1 if negation matches, 1 if there is
 * a positive match, 0 if there is no match at all.
 */
int
match_hostname(const char *host, const char *pattern, u_int len)
{
	return match_pattern_list(host, pattern, len, 1);
}

/*
 * returns 0 if we get a negative match for the hostname or the ip
 * or if we get no match at all.  returns -1 on error, or 1 on
 * successful match.
 */
int
match_host_and_ip(const char *host, const char *ipaddr,
    const char *patterns)
{
	int mhost, mip;

	/* error in ipaddr match */
	if ((mip = addr_match_list(ipaddr, patterns)) == -2)
		return -1;
	else if (mip == -1) /* negative ip address match */
		return 0;

	/* negative hostname match */
	if ((mhost = match_hostname(host, patterns, strlen(patterns))) == -1)
		return 0;
	/* no match at all */
	if (mhost == 0 && mip == 0)
		return 0;
	return 1;
}

/*
 * match user, user@host_or_ip, user@host_or_ip_list against pattern
 */
int
match_user(const char *user, const char *host, const char *ipaddr,
    const char *pattern)
{
	char *p, *pat;
	int ret;

	if ((p = strchr(pattern,'@')) == NULL)
		return match_pattern(user, pattern);

	pat = xstrdup(pattern);
	p = strchr(pat, '@');
	*p++ = '\0';

	if ((ret = match_pattern(user, pat)) == 1)
		ret = match_host_and_ip(host, ipaddr, p);
	xfree(pat);

	return ret;
}

/*
 * Returns first item from client-list that is also supported by server-list,
 * caller must xfree() returned string.
 */
#define	MAX_PROP	40
#define	SEP	","
char *
match_list(const char *client, const char *server, u_int *next)
{
	char *sproposals[MAX_PROP];
	char *c, *s, *p, *ret, *cp, *sp;
	int i, j, nproposals;

	c = cp = xstrdup(client);
	s = sp = xstrdup(server);

	for ((p = strsep(&sp, SEP)), i=0; p && *p != '\0';
	    (p = strsep(&sp, SEP)), i++) {
		if (i < MAX_PROP)
			sproposals[i] = p;
		else
			break;
	}
	nproposals = i;

	for ((p = strsep(&cp, SEP)), i=0; p && *p != '\0';
	    (p = strsep(&cp, SEP)), i++) {
		for (j = 0; j < nproposals; j++) {
			if (strcmp(p, sproposals[j]) == 0) {
				ret = xstrdup(p);
				if (next != NULL)
					*next = (cp == NULL) ?
					    strlen(c) : (u_int)(cp - c);
				xfree(c);
				xfree(s);
				return ret;
			}
		}
	}
	if (next != NULL)
		*next = strlen(c);
	xfree(c);
	xfree(s);
	return NULL;
}


text:
function model = parse_dpm_model(model, blocks)

for i = 1:length(model.rootfilters)
  s = size(model.w);
  width1 = ceil(s(2)/2);
  width2 = floor(s(2)/2);
  s(2) = width1;
  f = reshape(blocks(2), s);
  model.w(:,1:width1,:) = f;
  model.w(:,width1+1:end,:) = flipfeat(f(:,1:width2,:));
end

% update part filters and deformation models
for i = 1:length(model.partfilters)
  if model.partfilters{i}.fake
    continue;
  end

  model.defs{i}.w = reshape(blocks{model.defs{i}.blocklabel}, ...
                            size(model.defs{i}.w));
  partner = model.partfilters{i}.partner;
  if partner == 0
    % part is self-symmetric
    s = size(model.partfilters{i}.w);
    width1 = ceil(s(2)/2);
    width2 = floor(s(2)/2);
    s(2) = width1;
    f = reshape(blocks{model.partfilters{i}.blocklabel}, s);
    model.partfilters{i}.w(:,1:width1,:) = f;
    model.partfilters{i}.w(:,width1+1:end,:) = flipfeat(f(:,1:width2,:));
  else
    % part has a symmetric partner
    f = reshape(blocks{model.partfilters{i}.blocklabel}, ...
                size(model.partfilters{i}.w));
    model.partfilters{i}.w = f;
    model.partfilters{partner}.w = flipfeat(f);
    % flip linear term in horizontal deformation model
    model.defs{partner}.w = model.defs{i}.w;
    model.defs{partner}.w(2) = -1*model.defs{partner}.w(2);
  end
end

redpajama_set_name: RedPajamaGithub


text:
class AddTypeToBalls < ActiveRecord::Migration
  def change
    add_column :balls, :type, :string
  end
end


text:
<!doctype html>

  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">

  <title>Gates Foundation Spending - Vallandingham.me</title>
  <meta name="description" content="">
  <meta name="author" content="">

  <meta name="viewport" content="width=device-width,initial-scale=1">

  <link rel="stylesheet" href="css/reset.css">
  <link rel="stylesheet" href="css/bootstrap.min.css">
  <link rel="stylesheet" href="css/style.css">

Gates Foundation Educational Spending

        All Grants
        Grants By Year

A demonstration of animated bubble charts in D3.js

Blog Post | Code | Data


text:
<link href="#{skinPath}?v=#{cssVersion}" rel="stylesheet" type="text/css" />
<link href="~css/wojilu.app.content.admin.css?v=#{jsVersion}" rel="stylesheet" type="text/css" />

            :{setPageStyle}
            选择皮肤

                :{moreRowOp}

 :{addRow2}

 :{addRow1}

 :{addRow3}

 :{addRow4}

 :{addRow5}

 :{addRow6}

			         #{row.No}

			 :{deleteRow}

					    #{column.Name}

 :{addSection}

						         :{addContentSection}
							    (:{oneStep})

:{contentSectionTip}

						         :{addMashupSection}
							    (:{threeStep})

:{mashupSectionTip}

							     :{addRss}
							    (:{oneStep})

:{rssSectionTip}

 #{section.Title}

								_{admin}

 #{settting.Name}

 :{editStyleSection}

 :{editStyleTitle}

 :{editStyleContent}

 :{editEffect}

 :{deleteSection}

 :{combineSection}

:{removeSection}:#{r.Name}

#{section.Content}


text:
package io.netty.util.internal;

import static io.netty.util.internal.ObjectUtil.checkNonEmpty;

import io.netty.util.internal.logging.InternalLogger;
import io.netty.util.internal.logging.InternalLoggerFactory;

import java.security.AccessController;
import java.security.PrivilegedAction;

/**
 * A collection of utility methods to retrieve and parse the values of the Java system properties.
 */
public final class SystemPropertyUtil {

    private static final InternalLogger logger = InternalLoggerFactory.getInstance(SystemPropertyUtil.class);

    /**
     * Returns {@code true} if and only if the system property with the specified {@code key}
     * exists.
     */
    public static boolean contains(String key) {
        return get(key) != null;
    }

    /**
     * Returns the value of the Java system property with the specified
     * {@code key}, while falling back to {@code null} if the property access fails.
     *
     * @return the property value or {@code null}
     */
    public static String get(String key) {
        return get(key, null);
    }

    /**
     * Returns the value of the Java system property with the specified
     * {@code key}, while falling back to the specified default value if
     * the property access fails.
     *
     * @return the property value.
     *         {@code def} if there's no such property or if an access to the
     *         specified property is not allowed.
     */
    public static String get(final String key, String def) {
        checkNonEmpty(key, "key");

        String value = null;
        try {
            if (System.getSecurityManager() == null) {
                value = System.getProperty(key);
            } else {
                value = AccessController.doPrivileged(new PrivilegedAction<String>() {
                    @Override
                    public String run() {
                        return System.getProperty(key);
                    }
                });
            }
        } catch (SecurityException e) {
            logger.warn("Unable to retrieve a system property '{}'; default values will be used.", key, e);
        }

        if (value == null) {
            return def;
        }

        return value;
    }

    /**
     * Returns the value of the Java system property with the specified
     * {@code key}, while falling back to the specified default value if
     * the property access fails.
     *
     * @return the property value.
     *         {@code def} if there's no such property or if an access to the
     *         specified property is not allowed.
     */
    public static boolean getBoolean(String key, boolean def) {
        String value = get(key);
        if (value == null) {
            return def;
        }

        value = value.trim().toLowerCase();
        if (value.isEmpty()) {
            return def;
        }

        if ("true".equals(value) || "yes".equals(value) || "1".equals(value)) {
            return true;
        }

        if ("false".equals(value) || "no".equals(value) || "0".equals(value)) {
            return false;
        }

        logger.warn(
                "Unable to parse the boolean system property '{}':{} - using the default value: {}",
                key, value, def
        );

        return def;
    }

    /**
     * Returns the value of the Java system property with the specified
     * {@code key}, while falling back to the specified default value if
     * the property access fails.
     *
     * @return the property value.
     *         {@code def} if there's no such property or if an access to the
     *         specified property is not allowed.
     */
    public static int getInt(String key, int def) {
        String value = get(key);
        if (value == null) {
            return def;
        }

        value = value.trim();
        try {
            return Integer.parseInt(value);
        } catch (Exception e) {
            // Ignore
        }

        logger.warn(
                "Unable to parse the integer system property '{}':{} - using the default value: {}",
                key, value, def
        );

        return def;
    }

    /**
     * Returns the value of the Java system property with the specified
     * {@code key}, while falling back to the specified default value if
     * the property access fails.
     *
     * @return the property value.
     *         {@code def} if there's no such property or if an access to the
     *         specified property is not allowed.
     */
    public static long getLong(String key, long def) {
        String value = get(key);
        if (value == null) {
            return def;
        }

        value = value.trim();
        try {
            return Long.parseLong(value);
        } catch (Exception e) {
            // Ignore
        }

        logger.warn(
                "Unable to parse the long integer system property '{}':{} - using the default value: {}",
                key, value, def
        );

        return def;
    }

    private SystemPropertyUtil() {
        // Unused
    }
}


text:
//============================================================================
// Test to make sure we understand libproc
//============================================================================

#include <iostream>

#include "ProcEvents.h"

using namespace std;

int main(int argc, char *argv[]) {
    /**
     * ProcEvent::process()
     *  CNProc::connect()
     *  CNProc::subscribe() - proc events start to pile up
     *  openproc - send cur procs as events
     *  CNProc::process() - send along events
     */
    return 0;
}


text:
var siteConfig = require('../config/site');
var themeConfig = require('../themes/' + siteConfig.theme + '/config');

module.exports = {
  config: {},
  setConfig: function(group, key, val) {
    var config = this.config;
    if (!config[group]) {
      config[group] = {};
    }
    if (typeof key === 'object') {
      for (var prop in key) {
        if (key.hasOwnProperty(prop)) {
          config[group][prop] = key[prop];
        }
      }
    } else {
      config[group][key] = val;
    }
  },
  getConfig: function(group) {
    return this.config[group];
  },
  getStringValue: function(val) {
    switch(typeof val) {
      case 'boolean':
        return val ? 'true': 'false';
      case 'string':
        return "'" + val + "'";
      case 'number':
        return val;
      default:
        return "''";
    }
  },
  getConfigAsStringArray: function(group) {
    var config = this.getConfig(group);
    var arr = [];
    for(var key in config) {
      arr.push({
        key: key,
        val: this.getStringValue(config[key]),
        notLast: true
      });
    }
    arr[arr.length-1].notLast = false;
    return arr;
  }
};


text:
import { Button, color, Flex } from "@artsy/palette"
import { FormLabel } from "client/components/form_label"
import moment from "moment"
import React, { Component } from "react"
import ReactDOM from "react-dom"
import { ArticleData } from "reaction/Components/Publishing/Typings"
import styled from "styled-components"

interface ArticlePublishDateProps {
  article: ArticleData
  onChange: (key: string, value: any) => void
}

export class ArticlePublishDate extends Component<ArticlePublishDateProps> {
  public date
  public time

  state = {
    focus: false,
    hasChanged: false,
    publish_date: null,
    publish_time: null,
  }

  componentWillMount = () => {
    this.setState(this.setupPublishDate())
  }

  onScheduleChange = () => {
    const { article, onChange } = this.props
    const { scheduled_publish_at } = article
    const { hasChanged } = this.state

    if (this.date && this.time) {
      const date = this.date.value
      const time = this.time.value
      const new_published = moment(`${date} ${time}`)
        .local()
        .toISOString()

      if (scheduled_publish_at && !hasChanged) {
        this.onUnschedule()
      } else if (!article.published) {
        onChange("scheduled_publish_at", new_published)
      } else {
        onChange("published_at", new_published)
      }
      this.setState({ hasChanged: false })
    }
  }

  onUnschedule = () => {
    const { onChange } = this.props
    this.date.value = null
    this.time.value = null

    onChange("scheduled_publish_at", null)
    this.setState({ hasChanged: false, publish_date: null, publish_time: null })
  }

  setupPublishDate = () => {
    const { published_at, scheduled_publish_at } = this.props.article
    let publish_date
    let publish_time

    if (scheduled_publish_at) {
      publish_date = moment(scheduled_publish_at).format("YYYY-MM-DD")
      publish_time = moment(scheduled_publish_at).format("HH:mm")
    } else if (published_at) {
      publish_date = moment(published_at).format("YYYY-MM-DD")
      publish_time = moment(published_at).format("HH:mm")
    } else {
      publish_date = moment()
        .local()
        .format("YYYY-MM-DD")
      publish_time = moment()
        .local()
        .format("HH:mm")
    }

    return { publish_date, publish_time }
  }

  getPublishText = () => {
    const { hasChanged } = this.state
    const { published, scheduled_publish_at } = this.props.article

    if (published || (scheduled_publish_at && hasChanged)) {
      return "Update"
    } else if (scheduled_publish_at) {
      return "Unschedule"
    } else {
      return "Schedule"
    }
  }

  onChangeFocus = () => {
    if (this.date && this.time) {
      const dateIsFocused =
        document.activeElement === ReactDOM.findDOMNode(this.date)
      const timeIsFocused =
        document.activeElement === ReactDOM.findDOMNode(this.time)
      const hasChanged = this.hasChanged()

      this.setState({
        hasChanged,
        focus: dateIsFocused || timeIsFocused,
      })
    }
  }

  hasChanged = () => {
    const { publish_date, publish_time } = this.state

    if (this.date && this.time) {
      const dateHasChanged = publish_date !== this.date.value
      const timeHasChanged = publish_time !== this.time.value

      return dateHasChanged || timeHasChanged
    }
  }

  render() {
    const { focus, hasChanged, publish_date, publish_time } = this.state
    const {
      article: { scheduled_publish_at },
    } = this.props

    return (
      <div className="ArticlePublishDate">
        <FormLabel>Publish Date/Time</FormLabel>

        <Flex mt={1} mb={4}>
          <InputGroup
            hasFocus={focus}
            mr={1}
            onClick={this.onChangeFocus}
            onMouseUp={this.onChangeFocus}
            onKeyUp={this.onChangeFocus}
          >
            <input
              className="bordered-input"
              defaultValue={publish_date || ""}
              type="date"
              ref={ref => {
                this.date = ref
              }}
              onBlur={this.onChangeFocus}
            />
            <input
              className="bordered-input"
              defaultValue={publish_time || ""}
              type="time"
              ref={ref => {
                this.time = ref
              }}
              onBlur={this.onChangeFocus}
            />
          </InputGroup>

          <Button
            disabled={!hasChanged && !scheduled_publish_at}
            onClick={this.onScheduleChange}
            width="100%"
            height="auto"
          >
            {this.getPublishText()}
          </Button>
        </Flex>
      </div>
    )
  }
}

export const InputGroup = styled(Flex)<{ hasFocus?: boolean }>`
  min-width: 70%;
  border: 1px solid
    ${props => (props.hasFocus ? color("purple100") : color("black10"))};
  transition: border 0.25s;

  &:hover {
    border: 1px solid ${color("purple100")};
  }

  input,
  .bordered-input {
    border: none;
    margin-top: 3px;
  }
`


text:
#include <teb_local_planner/visualization.h>
#include <teb_local_planner/optimal_planner.h>
#include <teb_local_planner/FeedbackMsg.h>

namespace teb_local_planner
{

TebVisualization::TebVisualization() : initialized_(false)
{
}

TebVisualization::TebVisualization(ros::NodeHandle& nh, const TebConfig& cfg) : initialized_(false)
{
  initialize(nh, cfg);
}

void TebVisualization::initialize(ros::NodeHandle& nh, const TebConfig& cfg)
{
  if (initialized_)
    ROS_WARN("TebVisualization already initialized. Reinitalizing...");

  // set config
  cfg_ = &cfg;

  // register topics
  global_plan_pub_ = nh.advertise<nav_msgs::Path>("global_plan", 1);
  local_plan_pub_ = nh.advertise<nav_msgs::Path>("local_plan",1);
  teb_poses_pub_ = nh.advertise<geometry_msgs::PoseArray>("teb_poses", 100);
  teb_marker_pub_ = nh.advertise<visualization_msgs::Marker>("teb_markers", 1000);
  feedback_pub_ = nh.advertise<teb_local_planner::FeedbackMsg>("teb_feedback", 10);

  initialized_ = true;
}

void TebVisualization::publishGlobalPlan(const std::vector<geometry_msgs::PoseStamped>& global_plan) const
{
  if ( printErrorWhenNotInitialized() ) return;
  base_local_planner::publishPlan(global_plan, global_plan_pub_);
}

void TebVisualization::publishLocalPlan(const std::vector<geometry_msgs::PoseStamped>& local_plan) const
{
  if ( printErrorWhenNotInitialized() )
    return;
  base_local_planner::publishPlan(local_plan, local_plan_pub_);
}

void TebVisualization::publishLocalPlanAndPoses(const TimedElasticBand& teb) const
{
  if ( printErrorWhenNotInitialized() )
    return;

    // create path msg
    nav_msgs::Path teb_path;
    teb_path.header.frame_id = cfg_->map_frame;
    teb_path.header.stamp = ros::Time::now();

    // create pose_array (along trajectory)
    geometry_msgs::PoseArray teb_poses;
    teb_poses.header.frame_id = teb_path.header.frame_id;
    teb_poses.header.stamp = teb_path.header.stamp;

    // fill path msgs with teb configurations
    for (int i=0; i < teb.sizePoses(); i++)
    {
      geometry_msgs::PoseStamped pose;
      pose.header.frame_id = teb_path.header.frame_id;
      pose.header.stamp = teb_path.header.stamp;
      pose.pose.position.x = teb.Pose(i).x();
      pose.pose.position.y = teb.Pose(i).y();
      pose.pose.position.z = cfg_->hcp.visualize_with_time_as_z_axis_scale*teb.getSumOfTimeDiffsUpToIdx(i);
      pose.pose.orientation = tf::createQuaternionMsgFromYaw(teb.Pose(i).theta());
      teb_path.poses.push_back(pose);
      teb_poses.poses.push_back(pose.pose);
    }
    local_plan_pub_.publish(teb_path);
    teb_poses_pub_.publish(teb_poses);
}

void TebVisualization::publishRobotFootprintModel(const PoseSE2& current_pose, const BaseRobotFootprintModel& robot_model, const std::string& ns,
                                                  const std_msgs::ColorRGBA &color)
{
  if ( printErrorWhenNotInitialized() )
    return;

  std::vector<visualization_msgs::Marker> markers;
  robot_model.visualizeRobot(current_pose, markers, color);
  if (markers.empty())
    return;

  int idx = 1000000;  // avoid overshadowing by obstacles
  for (std::vector<visualization_msgs::Marker>::iterator marker_it = markers.begin(); marker_it != markers.end(); ++marker_it, ++idx)
  {
    marker_it->header.frame_id = cfg_->map_frame;
    marker_it->header.stamp = ros::Time::now();
    marker_it->action = visualization_msgs::Marker::ADD;
    marker_it->ns = ns;
    marker_it->id = idx;
    marker_it->lifetime = ros::Duration(2.0);
    teb_marker_pub_.publish(*marker_it);
  }

}

void TebVisualization::publishInfeasibleRobotPose(const PoseSE2& current_pose, const BaseRobotFootprintModel& robot_model)
{
  publishRobotFootprintModel(current_pose, robot_model, "InfeasibleRobotPoses", toColorMsg(0.5, 0.8, 0.0, 0.0));
}

void TebVisualization::publishObstacles(const ObstContainer& obstacles) const
{
  if ( obstacles.empty() || printErrorWhenNotInitialized() )
    return;

  // Visualize point obstacles
  {
    visualization_msgs::Marker marker;
    marker.header.frame_id = cfg_->map_frame;
    marker.header.stamp = ros::Time::now();
    marker.ns = "PointObstacles";
    marker.id = 0;
    marker.type = visualization_msgs::Marker::POINTS;
    marker.action = visualization_msgs::Marker::ADD;
    marker.lifetime = ros::Duration(2.0);

    for (ObstContainer::const_iterator obst = obstacles.begin(); obst != obstacles.end(); ++obst)
    {
      boost::shared_ptr<PointObstacle> pobst = boost::dynamic_pointer_cast<PointObstacle>(*obst);
      if (!pobst)
        continue;

      if (cfg_->hcp.visualize_with_time_as_z_axis_scale < 0.001)
      {
        geometry_msgs::Point point;
        point.x = pobst->x();
        point.y = pobst->y();
        point.z = 0;
        marker.points.push_back(point);
      }
      else // Spatiotemporally point obstacles become a line
      {
        marker.type = visualization_msgs::Marker::LINE_LIST;
        geometry_msgs::Point start;
        start.x = pobst->x();
        start.y = pobst->y();
        start.z = 0;
        marker.points.push_back(start);

        geometry_msgs::Point end;
        double t = 20;
        Eigen::Vector2d pred;
        pobst->predictCentroidConstantVelocity(t, pred);
        end.x = pred[0];
        end.y = pred[1];
        end.z = cfg_->hcp.visualize_with_time_as_z_axis_scale*t;
        marker.points.push_back(end);
      }
    }

    marker.scale.x = 0.1;
    marker.scale.y = 0.1;
    marker.color.a = 1.0;
    marker.color.r = 1.0;
    marker.color.g = 0.0;
    marker.color.b = 0.0;

    teb_marker_pub_.publish( marker );
  }

  // Visualize circular obstacles
  {
    std::size_t idx = 0;
    for (ObstContainer::const_iterator obst = obstacles.begin(); obst != obstacles.end(); ++obst)
    {
      boost::shared_ptr<CircularObstacle> pobst = boost::dynamic_pointer_cast<CircularObstacle>(*obst);
      if (!pobst)
        continue;

      visualization_msgs::Marker marker;
      marker.header.frame_id = cfg_->map_frame;
      marker.header.stamp = ros::Time::now();
      marker.ns = "CircularObstacles";
      marker.id = idx++;
      marker.type = visualization_msgs::Marker::SPHERE_LIST;
      marker.action = visualization_msgs::Marker::ADD;
      marker.lifetime = ros::Duration(2.0);
      geometry_msgs::Point point;
      point.x = pobst->x();
      point.y = pobst->y();
      point.z = 0;
      marker.points.push_back(point);

      marker.scale.x = pobst->radius();
      marker.scale.y = pobst->radius();
      marker.color.a = 1.0;
      marker.color.r = 0.0;
      marker.color.g = 1.0;
      marker.color.b = 0.0;

      teb_marker_pub_.publish( marker );
    }
  }

  // Visualize line obstacles
  {
    std::size_t idx = 0;
    for (ObstContainer::const_iterator obst = obstacles.begin(); obst != obstacles.end(); ++obst)
    {
      boost::shared_ptr<LineObstacle> pobst = boost::dynamic_pointer_cast<LineObstacle>(*obst);
      if (!pobst)
        continue;

      visualization_msgs::Marker marker;
      marker.header.frame_id = cfg_->map_frame;
      marker.header.stamp = ros::Time::now();
      marker.ns = "LineObstacles";
      marker.id = idx++;
      marker.type = visualization_msgs::Marker::LINE_STRIP;
      marker.action = visualization_msgs::Marker::ADD;
      marker.lifetime = ros::Duration(2.0);
      geometry_msgs::Point start;
      start.x = pobst->start().x();
      start.y = pobst->start().y();
      start.z = 0;
      marker.points.push_back(start);
      geometry_msgs::Point end;
      end.x = pobst->end().x();
      end.y = pobst->end().y();
      end.z = 0;
      marker.points.push_back(end);

      marker.scale.x = 0.1;
      marker.scale.y = 0.1;
      marker.color.a = 1.0;
      marker.color.r = 0.0;
      marker.color.g = 1.0;
      marker.color.b = 0.0;

      teb_marker_pub_.publish( marker );
    }
  }

  // Visualize polygon obstacles
  {
    std::size_t idx = 0;
    for (ObstContainer::const_iterator obst = obstacles.begin(); obst != obstacles.end(); ++obst)
    {
      boost::shared_ptr<PolygonObstacle> pobst = boost::dynamic_pointer_cast<PolygonObstacle>(*obst);
      if (!pobst)
				continue;

      visualization_msgs::Marker marker;
      marker.header.frame_id = cfg_->map_frame;
      marker.header.stamp = ros::Time::now();
      marker.ns = "PolyObstacles";
      marker.id = idx++;
      marker.type = visualization_msgs::Marker::LINE_STRIP;
      marker.action = visualization_msgs::Marker::ADD;
      marker.lifetime = ros::Duration(2.0);

      for (Point2dContainer::const_iterator vertex = pobst->vertices().begin(); vertex != pobst->vertices().end(); ++vertex)
      {
        geometry_msgs::Point point;
        point.x = vertex->x();
        point.y = vertex->y();
        point.z = 0;
        marker.points.push_back(point);
      }

      // Also add last point to close the polygon
      // but only if polygon has more than 2 points (it is not a line)
      if (pobst->vertices().size() > 2)
      {
        geometry_msgs::Point point;
        point.x = pobst->vertices().front().x();
        point.y = pobst->vertices().front().y();
        point.z = 0;
        marker.points.push_back(point);
      }
      marker.scale.x = 0.1;
      marker.scale.y = 0.1;
      marker.color.a = 1.0;
      marker.color.r = 1.0;
      marker.color.g = 0.0;
      marker.color.b = 0.0;

      teb_marker_pub_.publish( marker );
    }
  }
}

void TebVisualization::publishViaPoints(const std::vector< Eigen::Vector2d, Eigen::aligned_allocator<Eigen::Vector2d> >& via_points, const std::string& ns) const
{
  if ( via_points.empty() || printErrorWhenNotInitialized() )
    return;

  visualization_msgs::Marker marker;
  marker.header.frame_id = cfg_->map_frame;
  marker.header.stamp = ros::Time::now();
  marker.ns = ns;
  marker.id = 0;
  marker.type = visualization_msgs::Marker::POINTS;
  marker.action = visualization_msgs::Marker::ADD;
  marker.lifetime = ros::Duration(2.0);

  for (std::size_t i=0; i < via_points.size(); ++i)
  {
    geometry_msgs::Point point;
    point.x = via_points[i].x();
    point.y = via_points[i].y();
    point.z = 0;
    marker.points.push_back(point);
  }

  marker.scale.x = 0.1;
  marker.scale.y = 0.1;
  marker.color.a = 1.0;
  marker.color.r = 0.0;
  marker.color.g = 0.0;
  marker.color.b = 1.0;

  teb_marker_pub_.publish( marker );
}

void TebVisualization::publishTebContainer(const TebOptPlannerContainer& teb_planner, const std::string& ns)
{
if ( printErrorWhenNotInitialized() )
    return;

  visualization_msgs::Marker marker;
  marker.header.frame_id = cfg_->map_frame;
  marker.header.stamp = ros::Time::now();
  marker.ns = ns;
  marker.id = 0;
  marker.type = visualization_msgs::Marker::LINE_LIST;
  marker.action = visualization_msgs::Marker::ADD;

  // Iterate through teb pose sequence
  for( TebOptPlannerContainer::const_iterator it_teb = teb_planner.begin(); it_teb != teb_planner.end(); ++it_teb )
  {
    // iterate single poses
    PoseSequence::const_iterator it_pose = it_teb->get()->teb().poses().begin();
    TimeDiffSequence::const_iterator it_timediff = it_teb->get()->teb().timediffs().begin();
    PoseSequence::const_iterator it_pose_end = it_teb->get()->teb().poses().end();
    std::advance(it_pose_end, -1); // since we are interested in line segments, reduce end iterator by one.
    double time = 0;

    while (it_pose != it_pose_end)
    {
      geometry_msgs::Point point_start;
      point_start.x = (*it_pose)->x();
      point_start.y = (*it_pose)->y();
      point_start.z = cfg_->hcp.visualize_with_time_as_z_axis_scale*time;
      marker.points.push_back(point_start);

      time += (*it_timediff)->dt();

      geometry_msgs::Point point_end;
      point_end.x = (*boost::next(it_pose))->x();
      point_end.y = (*boost::next(it_pose))->y();
      point_end.z = cfg_->hcp.visualize_with_time_as_z_axis_scale*time;
      marker.points.push_back(point_end);
      ++it_pose;
      ++it_timediff;
    }
  }
  marker.scale.x = 0.01;
  marker.color.a = 1.0;
  marker.color.r = 0.5;
  marker.color.g = 1.0;
  marker.color.b = 0.0;

  teb_marker_pub_.publish( marker );
}

void TebVisualization::publishFeedbackMessage(const std::vector< boost::shared_ptr<TebOptimalPlanner> >& teb_planners,
                                              unsigned int selected_trajectory_idx, const ObstContainer& obstacles)
{
  FeedbackMsg msg;
  msg.header.stamp = ros::Time::now();
  msg.header.frame_id = cfg_->map_frame;
  msg.selected_trajectory_idx = selected_trajectory_idx;

  msg.trajectories.resize(teb_planners.size());

  // Iterate through teb pose sequence
  std::size_t idx_traj = 0;
  for( TebOptPlannerContainer::const_iterator it_teb = teb_planners.begin(); it_teb != teb_planners.end(); ++it_teb, ++idx_traj )
  {
    msg.trajectories[idx_traj].header = msg.header;
    it_teb->get()->getFullTrajectory(msg.trajectories[idx_traj].trajectory);
  }

  // add obstacles
  msg.obstacles_msg.obstacles.resize(obstacles.size());
  for (std::size_t i=0; i<obstacles.size(); ++i)
  {
    msg.obstacles_msg.header = msg.header;

    // copy polygon
    msg.obstacles_msg.obstacles[i].header = msg.header;
    obstacles[i]->toPolygonMsg(msg.obstacles_msg.obstacles[i].polygon);

    // copy id
    msg.obstacles_msg.obstacles[i].id = i; // TODO: we do not have any id stored yet

    // orientation
    //msg.obstacles_msg.obstacles[i].orientation =; // TODO

    // copy velocities
    obstacles[i]->toTwistWithCovarianceMsg(msg.obstacles_msg.obstacles[i].velocities);
  }

  feedback_pub_.publish(msg);
}

void TebVisualization::publishFeedbackMessage(const TebOptimalPlanner& teb_planner, const ObstContainer& obstacles)
{
  FeedbackMsg msg;
  msg.header.stamp = ros::Time::now();
  msg.header.frame_id = cfg_->map_frame;
  msg.selected_trajectory_idx = 0;

  msg.trajectories.resize(1);
  msg.trajectories.front().header = msg.header;
  teb_planner.getFullTrajectory(msg.trajectories.front().trajectory);

  // add obstacles
  msg.obstacles_msg.obstacles.resize(obstacles.size());
  for (std::size_t i=0; i<obstacles.size(); ++i)
  {
    msg.obstacles_msg.header = msg.header;

    // copy polygon
    msg.obstacles_msg.obstacles[i].header = msg.header;
    obstacles[i]->toPolygonMsg(msg.obstacles_msg.obstacles[i].polygon);

    // copy id
    msg.obstacles_msg.obstacles[i].id = i; // TODO: we do not have any id stored yet

    // orientation
    //msg.obstacles_msg.obstacles[i].orientation =; // TODO

    // copy velocities
    obstacles[i]->toTwistWithCovarianceMsg(msg.obstacles_msg.obstacles[i].velocities);
  }

  feedback_pub_.publish(msg);
}

std_msgs::ColorRGBA TebVisualization::toColorMsg(double a, double r, double g, double b)
{
  std_msgs::ColorRGBA color;
  color.a = a;
  color.r = r;
  color.g = g;
  color.b = b;
  return color;
}

bool TebVisualization::printErrorWhenNotInitialized() const
{
  if (!initialized_)
  {
    ROS_ERROR("TebVisualization class not initialized. You must call initialize or an appropriate constructor");
    return true;
  }
  return false;
}

} // namespace teb_local_planner


text:
// Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Microsoft.Build.Execution;
using Microsoft.DotNet.Cli.Utils;
using Microsoft.DotNet.Tools.MSBuild;

namespace Microsoft.DotNet.Tools.Run
{
    public partial class RunCommand
    {
        public string Configuration { get; set; }
        public string Framework { get; set; }
        public string Project { get; set; }
        public IReadOnlyList<string> Args { get; set; }

        private List<string> _args;

        public RunCommand()
        {
        }

        public int Start()
        {
            Initialize();

            EnsureProjectIsBuilt();

            ICommand runCommand = GetRunCommand();

            return runCommand
                .Execute()
                .ExitCode;
        }

        private void EnsureProjectIsBuilt()
        {
            List<string> buildArgs = new List<string>();

            buildArgs.Add(Project);

            buildArgs.Add("/nologo");
            buildArgs.Add("/verbosity:quiet");

            if (!string.IsNullOrWhiteSpace(Configuration))
            {
                buildArgs.Add($"/p:Configuration={Configuration}");
            }

            if (!string.IsNullOrWhiteSpace(Framework))
            {
                buildArgs.Add($"/p:TargetFramework={Framework}");
            }

            var buildResult = new MSBuildForwardingApp(buildArgs).Execute();

            if (buildResult != 0)
            {
                Reporter.Error.WriteLine();
                throw new GracefulException(LocalizableStrings.RunCommandException);
            }
        }

        private ICommand GetRunCommand()
        {
            Dictionary<string, string> globalProperties = new Dictionary<string, string>()
            {
                { LocalizableStrings.RunCommandMSBuildExtensionsPath, AppContext.BaseDirectory }
            };

            if (!string.IsNullOrWhiteSpace(Configuration))
            {
                globalProperties.Add(LocalizableStrings.RunCommandConfiguration, Configuration);
            }

            if (!string.IsNullOrWhiteSpace(Framework))
            {
                globalProperties.Add(LocalizableStrings.RunCommandTargetFramework, Framework);
            }

            ProjectInstance projectInstance = new ProjectInstance(Project, globalProperties, null);

            string runProgram = projectInstance.GetPropertyValue(LocalizableStrings.RunCommandProjectInstance);
            if (string.IsNullOrEmpty(runProgram))
            {
                string outputType = projectInstance.GetPropertyValue(LocalizableStrings.RunCommandOutputType);

                throw new GracefulException(string.Join(Environment.NewLine,
                    LocalizableStrings.RunCommandExceptionUnableToRun1,
                    LocalizableStrings.RunCommandExceptionUnableToRun2,
                    $"{LocalizableStrings.RunCommandExceptionUnableToRun3}'{outputType}'."));
            }

            string runArguments = projectInstance.GetPropertyValue(LocalizableStrings.RunCommandRunArguments);
            string runWorkingDirectory = projectInstance.GetPropertyValue(LocalizableStrings.RunCommandRunWorkingDirectory);

            string fullArguments = runArguments;
            if (_args.Any())
            {
                fullArguments += " " + ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(_args);
            }

            CommandSpec commandSpec = new CommandSpec(runProgram, fullArguments, CommandResolutionStrategy.None);

            return Command.Create(commandSpec)
                .WorkingDirectory(runWorkingDirectory);
        }

        private void Initialize()
        {
            if (string.IsNullOrWhiteSpace(Project))
            {
                string directory = Directory.GetCurrentDirectory();
                string[] projectFiles = Directory.GetFiles(directory, "*.*proj");

                if (projectFiles.Length == 0)
                {
                    throw new InvalidOperationException(
                        $"{LocalizableStrings.RunCommandInvalidOperationException1} {directory}." + Environment.NewLine +
                        LocalizableStrings.RunCommandInvalidOperationException2);
                }
                else if (projectFiles.Length > 1)
                {
                    throw new InvalidOperationException(
                        $"{LocalizableStrings.RunCommandInvalidOperationException3}'{directory}'{LocalizableStrings.RunCommandInvalidOperationException4}");
                }

                Project = projectFiles[0];
            }

            if (Args == null)
            {
                _args = new List<string>();
            }
            else
            {
                _args = new List<string>(Args);
            }
        }
    }
}


text:
type PyError <: Exception
    msg::AbstractString # message string from Julia context, or "" if none

    # info returned by PyErr_Fetch/PyErr_Normalize
    T::PyObject
    val::PyObject
    traceback::PyObject

    # generate a PyError object.  Should normally only be called when
    # PyErr_Occurred returns non-NULL, and clears the Python error
    # indicator.
    function PyError(msg::AbstractString)
        exc = Array(PyPtr, 3)
        pexc = convert(Uint, pointer(exc))
        # equivalent of passing C pointers &exc[1], &exc[2], &exc[3]:
        ccall((@pysym :PyErr_Fetch), Void, (Uint,Uint,Uint),
              pexc, pexc + sizeof(PyPtr), pexc + 2*sizeof(PyPtr))
        ccall((@pysym :PyErr_NormalizeException), Void, (Uint,Uint,Uint),
              pexc, pexc + sizeof(PyPtr), pexc + 2*sizeof(PyPtr))
        new(msg, exc[1], exc[2], exc[3])
    end
end

function show(io::IO, e::PyError)
    print(io, "PyError",
          isempty(e.msg) ? e.msg : string(" (",e.msg,")"),
          " ")

    if e.T.o == C_NULL
        println(io, "None")
    else
        println(io, pystring(e.T), "\n", pystring(e.val))
    end

    if e.traceback.o != C_NULL
        o = pycall(format_traceback, PyObject, e.traceback)
        if o.o != C_NULL
            for s in PyVector{AbstractString}(o)
                print(io, s)
            end
        end
    end
end

#########################################################################
# Conversion of Python exceptions into Julia exceptions

# call to discard Python exceptions
pyerr_clear() = ccall((@pysym :PyErr_Clear), Void, ())

function pyerr_check(msg::AbstractString, val::Any)
    if ccall((@pysym :PyErr_Occurred), PyPtr, ()) != C_NULL
        throw(PyError(msg))
    end
    val # the val argument is there just to pass through to the return value
end

pyerr_check(msg::AbstractString) = pyerr_check(msg, nothing)
pyerr_check() = pyerr_check("")

# extract function name from ccall((@pysym :Foo)...) or ccall(:Foo,...) exprs
callsym(s::Symbol) = s
callsym(s::QuoteNode) = s.value
import Base.Meta.isexpr
callsym(ex::Expr) = isexpr(ex,:macrocall,2) ? callsym(ex.args[2]) : isexpr(ex,:ccall) ? callsym(ex.args[1]) : ex

# Macros for common pyerr_check("Foo", ccall((@pysym :Foo), ...)) pattern.
macro pycheck(ex)
    :(pyerr_check($(string(callsym(ex))), $ex))
end

# Macros to check that ccall((@pysym :Foo), ...) returns value != bad
macro pycheckv(ex, bad)
    quote
        val = $ex
        if val == $bad
            # throw a PyError if available, otherwise throw ErrorException
            pyerr_check($(string(callsym(ex))))
            error($(string(callsym(ex))), " failed")
        end
        val
    end
end
macro pycheckn(ex)
    :(@pycheckv $ex C_NULL)
end
macro pycheckz(ex)
    :(@pycheckv $ex -1)
end

#########################################################################
# Mapping of Julia Exception types to Python exceptions

const pyexc = Dict{DataType, PyPtr}()
type PyIOError <: Exception end

macro pyglobalobjptr(name)
    :(unsafe_load(cglobal(($name, libpython), Ptr{PyObject_struct})))
end

function pyexc_initialize()
    pyexc[Exception] = @pyglobalobjptr :PyExc_RuntimeError
    pyexc[ErrorException] = @pyglobalobjptr :PyExc_RuntimeError
    pyexc[SystemError] = @pyglobalobjptr :PyExc_SystemError
    pyexc[TypeError] = @pyglobalobjptr :PyExc_TypeError
    pyexc[ParseError] = @pyglobalobjptr :PyExc_SyntaxError
    pyexc[ArgumentError] = @pyglobalobjptr :PyExc_ValueError
    pyexc[KeyError] = @pyglobalobjptr :PyExc_KeyError
    pyexc[LoadError] = @pyglobalobjptr :PyExc_ImportError
    pyexc[MethodError] = @pyglobalobjptr :PyExc_RuntimeError
    pyexc[EOFError] = @pyglobalobjptr :PyExc_EOFError
    pyexc[BoundsError] = @pyglobalobjptr :PyExc_IndexError
    pyexc[DivideError] = @pyglobalobjptr :PyExc_ZeroDivisionError
    pyexc[DomainError] = @pyglobalobjptr :PyExc_RuntimeError
    pyexc[OverflowError] = @pyglobalobjptr :PyExc_OverflowError
    pyexc[InexactError] = @pyglobalobjptr :PyExc_ArithmeticError
    pyexc[MemoryError] = @pyglobalobjptr :PyExc_MemoryError
    pyexc[StackOverflowError] = @pyglobalobjptr :PyExc_MemoryError
    pyexc[UndefRefError] = @pyglobalobjptr :PyExc_RuntimeError
    pyexc[InterruptException] = @pyglobalobjptr :PyExc_KeyboardInterrupt
    pyexc[PyIOError] = @pyglobalobjptr :PyExc_IOError
end

function pyraise(e)
    eT = typeof(e)
    pyeT = haskey(pyexc::Dict, eT) ? pyexc[eT] : pyexc[Exception]
    ccall((@pysym :PyErr_SetString), Void, (PyPtr, Ptr{Uint8}),
          pyeT, bytestring(string("Julia exception: ", e)))
end

function pyraise(e::PyError)
    ccall((@pysym :PyErr_Restore), Void, (PyPtr, PyPtr, PyPtr),
          e.T, e.val, e.traceback)
    e.T.o = e.val.o = e.traceback.o = C_NULL # refs were stolen
end


text:
'use strict';

import React, {
    StyleSheet
}
from 'react-native';

import constants from './constants.js';

const styles = StyleSheet.create({
    container: {
        flex: 1,
        // justifyContent: 'center',
        // alignItems: 'center',
        flexDirection: 'column',
        backgroundColor: '#f2f2f2',
    },
    userInfo: {
        alignItems: 'center',
        backgroundColor: '#fff',
        borderBottomColor: '#eee',
        borderColor: 'transparent',
        borderWidth: 1,
        justifyContent: 'center',
        height: 44
    },
    userInfoName: {
        color: '#444',
        fontSize: 16,
        fontWeight: "500"
    },

    userActionsButtons: {
        flex: 1,
        flexDirection: 'column',
        // justifyContent: 'space-around',
        // alignItems: 'center'
    },
    userActionsButtonsRow: {
        flex:1,
        flexDirection: 'row',
        // justifyContent: 'space-around'
    },
    userActionsButton: {
        flex: 1,
        backgroundColor: '#fff',
        flexDirection: 'row',
        justifyContent: 'center',
        alignItems: 'center',
    },
    userActionsButtonImage:{
        width: 150,
        height: 150,
    },

    userActionsAccept: {
        flex: 2
    },
    userActionsCancel: {
        flex: 1
    },

    diceList: {
        height: 50
    },
    diceListScroll: {
        flexDirection: 'row'
    },
    diceListDie: {
        height: 50,
        width: 50,
        resizeMode: 'contain'
    },

    separatorV: {
        height: 50,
        width: 5,
        borderWidth: 0,
        // borderColor: '#fff',
        backgroundColor: 'red'
    },

    action: {
        borderColor: 'transparent',
        borderWidth: 1,
        paddingLeft: 16,
        paddingTop: 14,
        paddingBottom: 16,
    },
    actionText: {
        color: '#fff',
        fontSize: 16,
        textAlign: 'center',
    },
    actionSuccess: {
        backgroundColor: constants.actionSuccessColor
    },
    actionCancel: {
        backgroundColor: constants.actionCancelColor
    }
});

module.exports = styles;


text:
<?xml version="1.0" encoding="windows-1252"?>

<document xmlns:p="http://www.orbeon.com/oxf/pipeline" xmlns:xforms="http://www.w3.org/2002/xforms"
        xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:xxforms="http://orbeon.org/oxf/xml/xforms"
        xmlns:oxf="http://www.orbeon.com/oxf/processors" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:sql="http://orbeon.org/oxf/xml/sql" xmlns:xs="http://www.w3.org/2001/XMLSchema"
        xmlns:xi="http://www.w3.org/2001/XInclude" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
        xmlns:ev="http://www.w3.org/2001/xml-events">

        <title>Changes in Version 3.6</title>

            <title>Introduction</title>

                Welcome to Orbeon Forms 3.6!

                Orbeon Forms 3.6 features over 170 improvements since Orbeon Forms 3.5.1, including major improvements in the areas of state
                handling, XML Schema validation, error handling, deployment within Java applications, and performance.

                This document describes changes made between Orbeon Forms 3.5.1 and Orbeon Forms 3.6.

            <title>Changes in Version 3.6</title>

                Orbeon Forms 3.6 is an update to Orbeon Forms 3.5.1.

                <title>Noteworthy Changes</title>

                            The XForms engine features a disk-based state store. Before this version, when using
                            session state handling, XForm state information was stored in the user's
                            session. Because the size of the session information was limited, state information could
                            expire and cause certain XForms pages to no longer function when too much memory was used.

                            Orbeon Forms now implements a disk-based state store, which allows state information to be
                            stored on disk when the memory state store becomes too large. You enable this state store
                            with the new server configuration value for the
                            oxf.xforms.state-handling property. This is now the default state handling
                            configuration, and when migrating to this version or Orbeon Forms we recommend that you
                            update your properties with the following:

                        <xml-source>
                            <comment> Store state on the server </comment>
                            <property as="xs:string" name="oxf.xforms.state-handling" value="server"/>
                        </xml-source>

                            The memory state store is now global and shared among all users and pages. Its size is
                            configured with the following property:

                        <xml-source>
                            <comment> Allow a maximum of 20 MB of state information among all users </comment>
                            <property as="xs:integer" name="oxf.xforms.store.application.size" value="20000000"/>
                        </xml-source>

                            For more information about configuration, see State Handling.

                            Bindings support types imported from XML Schemas. In previous versions, only built-in
                            types such as xs:integer, xs:date, etc. were supported on the
                            type attribute of <xforms:bind> element. In this version,
                            simple types declared in an imported XML Schema can be used. For example, assume the
                            following schema declaring a type called my:state:

                        <xml-source>
                            <xs:schema targetNamespace="http://orbeon.org/oxf/examples/my"
                                       xmlns:my="http://orbeon.org/oxf/examples/my"
                                       xmlns:xs="http://www.w3.org/2001/XMLSchema"
                                       elementFormDefault="qualified"
                                       attributeFormDefault="unqualified">
                                <xs:simpleType name="state">
                                    <xs:restriction base="xs:string">
                                        <xs:enumeration value="AL"/>
                                        <xs:enumeration value="AK"/>
                                        <xs:enumeration value="AZ"/>
                                        ...
                                        <xs:enumeration value="GU"/>
                                        <xs:enumeration value="MP"/>
                                        <xs:enumeration value="PR"/>
                                    </xs:restriction>
                                </xs:simpleType>
                            </xs:schema>
                        </xml-source>

                            You use <xforms:bind> to assign this type as follows:

                        <xml-source>
                            <xforms:bind nodeset="address/state" type="my:state"/>
                        </xml-source>

                            Note that with XForms 1.1, the type attribute only supports simple types, or
                            complex types with simple content. Orbeon Forms only support simple types at the moment.

                            See issue #306753.

                            Improved XML Schema validation. In previous versions, XML Schema validation always
                            followed a strict mode where all instances had to be strictly valid as per imported schema
                            definitions. In particular, this meant that if you imported a schema, the top-level element
                            of an instance had to have a valid schema definition or the instance would be entirely
                            invalid.

                            In this version, Orbeon Forms implements a "lax" validation mode by default, where only
                            elements that have definitions in the imported schemas are validated. Other elements are not
                            considered for validation. This is in line with XML Schema and XSLT 2.0 lax validation
                            modes.

                            In addition, the author can specify the validation mode directly on each instance with the
                            extension xxforms:validation attribute, which takes values lax
                            (the default), strict (the root element has to have a definition in the schema
                            and must be valid), or skip (no validation at all for that instance).

                            Nodes validated through a schema now receive datatype annotations, which means that if an
                            element or attribute is validated against xs:date in a schema, an XForms
                            control bound to that node will display a date picker. Previously, you had to bind the type
                            with a binding even if you used a schema:

                        <xml-source>
                            <xforms:bind nodeset="..." type="xs:date"/>
                        </xml-source>

                            This is now no longer necessary if you use a schema. Of course if you don't use a schema, or
                            if you want to perform validation in addition to what is picked-up by a schema, then using
                            <xforms:bind> is still the correct way of binding types.

                            See issues #307140,
                            #307141
                            and #305063.

                            Support for XForms 1.1 types allowing empty content. Several built-in XML Schema data
                            types, such as xs:date, do not consider an empty string as a valid value. This
                            makes it difficult, for example, to specify the type "optional date" in XForms. With XForms
                            1.1, every built-in data type has a counterpart in the xforms namespace, which
                            adds the empty string as a valid value. These types are now supported in Orbeon Forms. For
                            example, you denote an optional date in an instance with:

                        <xml-source>
                            <xforms:bind nodeset="..." type="xforms:date"/>
                        </xml-source>

                            See issue #307162.

                            Memory usage improvements. The way XForms Model Item Properties (MIPs) are
                            implemented has changed since Orbeon Forms 3.5.1. A memory profiler has revealed that a very
                            large number of objects related to MIPs were created. The implementation has been modified
                            to drastically reduce the number of such objects, with an expected benefit of reduced memory
                            usage and less garbage collection time.

                            Thanks to Adrian Baker and to CSC for their work and support regarding this issue.

                            See issue #307388.

                            Help displayed as separate help panel. Orbeon Forms now displays help messages
                            (defined with xforms:help) in a separate help panel:

                            The help panel appears when the user selects a help icon. It stays open until closed by the
                            user, and can be moved around the page. See the XForms Reference for more
                            information.

                            Hints displayed as tooltips. Orbeon Forms now displays control hints (defined with
                            xforms:hint) as tooltips:

                            Hints appear when you mouse over a field, and disappear after a while. See the XForms Reference for more
                            information.

                            Better display of JavaScript and Ajax errors. Orbeon Forms now displays JavaScript
                            and Ajax errors in a user-friendly error dialog:

                            An initially collapsed section containing details of the error useful to the developer:

                            See issue #307198.
                            Also visit the updated error page and error dialog
                            documentation.

                            Improved XForms error location information. What's more frustrating during form
                            development than seeing cryptic errors and not being able to find out what exact line of
                            code caused the problem? Orbeon Forms now supports much enhanced file name and line number
                            reporting in XForms. In many cases, error messages now indicate an exact file name and line
                            number, along with a better call stack:

                            Note that this currently requires setting the following property in properties.xml:

                        <xml-source>
                            <property as="xs:boolean" processor-name="oxf:saxon8" name="generate-source-location" value="true"/>
                        </xml-source>
                        <note>

                                This property should usually be turned off in deployment, as line number handling with
                                XSLT currently has a noticeable impact on performance.

                        </note>

                            See issue #306558.

                            Support for deployment as separate WAR. Orbeon Forms can now be deployed as a Java
                            web application archive (WAR) separate from your Java application. This is most useful when
                            you want to produce XForms using Java technology (whether using JSP, Java Servlets, or other
                            frameworks).

                            Using XForms with your Java applications was already possible in the past, but you had to
                            either copy over all the Orbeon Forms JAR files and configuration files into your
                            application, or the other way around. The new deployment method allows you to deploy Orbeon
                            Forms separately. You just need to include a very small Orbeon Forms JAR file in your
                            application (orbeon-xforms-filter.jar), and to add a short configuration for a
                            filter to your web.xml.

                            Separate deployment has several benefits including:

                                    Easier upgrades of both your application and Orbeon Forms.

                                    Preventing situations where different versions of JAR files could conflict.

                                    Cleaner application architecture.

                            See Using the Orbeon Forms XForms Engine with Java
                            Applications for more information.

                            Thanks to Adrian Baker and Leigh Klotz for their input.

                            Improved support for built-in JSP deployment. Deploying JavaServer Pages (JSP)
                            directly into Orbeon Forms is now better documented and uses the same mechanism used when
                            deploying Orbeon Forms as a separate WAR. In addition, using setContentType()
                            at the beginning of JSP files is no longer necessary.

                            See Using the Orbeon Forms XForms Engine with Java
                            Applications for more information.

                            Support for boolean type in input fields. Previously, <xforms:input>
                            controls bound to nodes of type xs:boolean would display a regular input field.
                            The control now shows a checkbox allowing to better select a boolean value. See issue #306628.

                            Support for <xforms:group> around <xhtml:tr>. This didn't
                            work reliably in previous versions. This in particular allows controlling the visibility of
                            table rows using <xforms:group>, for example:

                        <xml-source>
                            <xhtml:table>
                                <xhtml:tr>
                                    <xhtml:th>Name</xhtml:th>
                                </xhtml:tr>
                                <xforms:group ref="person[address/state = 'CA']">
                                    <xhtml:tr>
                                        <xhtml:td>
                                            <xforms:output ref="name"/>
                                        </xhtml:td>
                                    </xhtml:tr>
                                </xforms:group>
                            </xhtml:table>
                        </xml-source>

                            Note that whether XForms implementations should support XForms elements around table rows and
                            cells is a matter of debate, but Orbeon Forms already supports <xforms:repeat>
                            around table rows for the convenience of form authors, and supporting groups is a matter of
                            consistency.

                            See issue #306259.

                            Support for optimization hint on selection controls. The new
                            xxforms:refresh-items attribute on selection controls allows for performance
                            improvements in certain cases. See Controlling Item Sets Refreshes with
                            xxforms:refresh-items.

                            See issue #307152.

                            Firebug Lite ships with Orbeon Forms. If you wish to debug JavaScript with Firebug
                            Lite, you don't need anymore to include your own copy of Firebug Lite. Instead you can use
                            the one that comes by default
                            with Orbeon Forms.

                <title>Complete List of Issues Addressed in this Release</title>

                    Orbeon Forms 3.6 addresses over 170 bugs and features:

                        #307983:
                            Regression: read-only date fields show date picker icon

                        #307948:
                            xforms:date type doesn't apply to newly inserted repeat items

                        #307917:
                            Instance replaced flag is not correctly restored from dynamic state

                        #307913:
                            Use "orbeon" as project name instead of "ops"

                        #307915:
                            Servlet initialization and destruction listeners must be commented out by default

                        #307767:
                            RFE: Make unit tests for persistent XForms state store

                        #307867:
                            Activating an HTML link containing an xforms:output may cause later browser back to fail

                        #307810:
                            Form field values are sometimes not sent to the Ajax server

                        #305901:
                            xforms:help does innerHTML instead of handling the content as text

                        #307455:
                            Logout example: still shows the page as if logged in after logging out

                        #306794:
                            XPL, XQuery, XSLT, XPath and XUpdate sandboxes don't show results anymore

                        #307831:
                            Google Suggests example doesn't work anymore

                        #307821:
                            Combined JavaScript and CSS files should include an Orbeon Forms version number

                        #307812:
                            Two submissions with replace="all" in a row throw an exception

                        #307811:
                            "There is already an active submission." error when going back and forth quickly

                        #307803:
                            Submitting an instance with bound upload controls doesn't work upon xforms-ready

                        #307701:
                            Issue with adjacent itemsets

                        #307454:
                            Inspector does not show initial XML (in some cases)

                        #307579:
                            Label is not hidden when repeat iteration is added

                        #307777:
                            RFE: Client error dialog should provide a link to reload the page

                        #307744:
                            Error when using browser back button when using xforms:instance[@src = 'input:*']

                        #307770:
                            Control hints should display as tooltips

                        #307766:
                            Make xforms:select work in non-destructive mode

                        #307691:
                            RFE: Implement persistent XForms state store

                        #307748:
                            Upgrade log4j to latest 1.2

                        #307745:
                            Cookies and authorization credentials may be sent across different page invocations

                        #307718:
                            YUI connection: do not catch exception and do nothing

                        #307719:
                            JS error in IE when canceling navigation away from current page

                        #307717:
                            JavaScript error: element.hasAttribute is not a function

                        #307715:
                            NPE upon submission with upload when no session is available

                        #307707:
                            Instance replacement upon xforms-ready causes type="xs:date" bind to malfunction

                        #307690:
                            xforms:output must require @ref or @value

                        #307674:
                            Regression: Instance submission with upload no longer dispatches xforms-submit-done

                        #307644:
                            NPE when dispatching
                            event with xforms:dispatch to invalid target ID

                        #307612:
                            HTML help does not update correctly upon Ajax response

                        #307608: oxf:pdf-template
                            processor outputs malformed XML document

                        #307607: RFE:
                            oxf:pdf-template does not support XSLT date and time formatting functions

                        #307604: Ajax retry code
                            causes duplicate submission and JavaScript error

                        #307599: Reduce contention
                            in DatabaseContext

                        #306446:
                            xforms:group/@appearance="xxforms:fieldset" must support change of label value

                        #307556: Type of node a
                            group is bound to (date) is incorrectly used for child controls of the group bound to nodes that are not of that type

                        #307524: XForms upload
                            control does not become read-only when the read-only MIP is changed after the page loads

                        #306668: RFE: Instance
                            Inspector should have XPath evaluator

                        #307503: RFE: Retry
                            mechanism for Ajax queries

                        #307470: RFE: Optimize
                            Ajax response to not include default attribute values

                        #307483: Turning off the
                            XForms document cache causes invalid controls updates when relevance changes

                        #307482: Submission with
                            replace="all" and xxforms:target causes source form to behave incorrectly

                        #306625: RFE: Support
                            target window on xf:submission/@replace="all"

                        #307474: HTML and XHTML
                            serialization in epilogue should have zero indent level to reduce document size

                        #307446: JavaScript
                            exception when using innerHTML with non-escaped markup with XHTML in Firefox

                        #307472: RFE: Connection
                            pooling for HTTP connections

                         #307439:
                             Rewrite does not change applet/@archive

                        #307442:
                            Government Forms example summary initially shows repeat index value of 0

                        #307434:
                            Optimize refresh upon instance replacement

                        #307407:
                            xforms-value-changes called more times than expected

                        #307431:
                            Avoid dom4j conversion when using JTidy used by xforms:output

                        #305588:
                            RFE: Support instance/src="input:data"

                        #307425:
                            SAXStore keeps references to Locator, causing memory leaks

                        #306695:
                            XPathCache.getXPathExpression doesn't cache across requests

                        #307424:
                            XFormsFunctionLibrary leaks by keeping references to XFormsModel and XFormsControls objects

                        #307367:
                            Deployment in Liferay 4.3.0 is broken

                        #307416:
                            java.lang.ClassCastException: ElementImpl cannot be cast to NodeWrapper

                        #307403:
                            Non-relevant group label is initially visible

                        #307401:
                            Regression: XInclude processor no longer caches

                        #307384:
                            SOAPAction HTTP header is not set

                        #307355:
                            RFE: dispatchEvent to provide additional attribute ignoreErrors

                        #307363:
                            neighbor attribute should be on xxforms:show

                        #307390:
                            RFE: Government Forms example needs button to discard changes and go back to summary

                        #307389:
                            Date input should use img instead of label to work around background image IE bug

                        #307388:
                            Lazily create MIP information

                        #307386:
                            Special characters are not supported in submission authentication

                        #307380:
                            xforms:group generates HTML markup for a label even if no child xforms:label is present

                        #307377:
                            Cursor not visible in input fields

                        #307356:
                            Image in label set on file upload shown as escaped text

                        #307361:
                            Submission must perform rebuild/recalculate before submitting if needed

                        #307358:
                            Update to HSQLDB version 1.8.0.7

                        #307354:
                            Incorrect current value of repeat index when clicking on external trigger

                        #307255:
                            "Error while processing response" appears when you follow a link and Ajax requests are being processed

                        #307281:
                            RFE: Solution to fire MIP events upon initialization

                        #307336:
                            The first click on an item in a list does not send an xforms-value-changed to the server

                        #306597:
                            Client doesn't support updates to hierarchical itemsets

                        #307327:
                            Remove obsolete Struts configuration files from WEB-INF

                        #307331:
                            ClassCastException in submission with redirection

                        #307330:
                            Error when closing orange error dialog when there is only one form on the page

                        #307231:
                            Document error.xsl configuration

                        #307283:
                            RFE: Upgrade to Xerces 2.9

                        #307268:
                            position() within repeat: works with output value="..., but not in ref="..."

                        #307261:
                            XPath expression not evaluated in the correct context?

                        #307267:
                            Government Forms detail: switching language no longer switches birth date format

                        #307252:
                            Add section about support (mailing-list, commercial) in FAQ

                        #307240:
                            DMV form's zip code definition is incorrect

                        #307238:
                            Mediatype text/html does not process HTML iframe element

                        #306498:
                            Some CSS files are duplicated between resources and ops-resources-public.jar

                        #307237: URL
                            rewriting does not rewrite attributes of xhtml:object

                        #307236:
                            Missing or incorrect location data when certain errors occur within xforms:repeat

                        #307232:
                            Inaccurate description of how to customize the jscalendar

                        #307229:
                            Required but empty selection controls are not properly styled

                        #307227:
                            Regression: MIPs are lost upon submission

                        #304746:
                            Default date formatting improvements

                        #306558:
                            RFE: Improve error location information

                        #307224:
                            RFE: Application shared instances should have expiration option

                        #307198:
                            Errors occurring during Ajax requests must also indicate location data and stack trace

                        #306408:
                            XSLT errors no longer show in stack traces

                        #307210:
                            Move current error.xpl to private resources

                        #307056:
                            Session cache stores too much information and causes early expiration of entries

                        #307209:
                            Incorrect request id returned to client upon back/reload

                        #307208:
                            Document cache not used in client state mode

                        #307207:
                            Control with xxforms:refresh-items="false" doesn't show correct items when becoming relevant

                        #307025:
                            XForms controls: "add carrier" has no effect with client-side event handling

                        #307202:
                            Should restore authentication example

                        #307201:
                            RFE: oxf:request-security should provide access to the user principal when available

                        #307191:
                            Error page no longer shows XML elements

                        #307165:
                            RFE: Implement "Human Readable Resource Identifiers"

                        #307176:
                            Upgrade to FOP 0.93

                        #307174:
                            Error: Pipeline input "forms" is not connected, while the input is indeed connected

                        #307007:
                            Fix back how client obtains server name

                        #307162:
                            RFE: Support XForms 1.1 datypes to allow empty content

                        #307161:
                            Disable verbose logging of eXist storage access

                        #307160:
                            Rename theme-portal.xsl to theme-examples.xsl

                        #307159:
                            Schemas for XPL must support foreign attributes

                        #306570:
                            Evaluation of XPath expressions in repeat returns incorrect result

                        #306421:
                            Non-required blank date does not appear invalid

                        #304934:
                            Incorrect validation when using xsi:type on root element

                        #305063:
                            xs:date bound through schema doesn't cause date picker to display

                        #304152:
                            Schema validation should be checked against spec

                        #306010:
                            Schema validation doesn't check if a schema definition is "applicable"

                        #307153:
                            XML Schema validation must support complex types with simple content

                        #307152:
                            RFE: Support constant itemsets for xforms:select1 and xforms:select

                        #307151:
                            Split XForms reference documentation into two pages

                        #307140:
                            Implement lax XML Schema validation

                        #307141:
                            RFE: Support user-controlled "lax", "strict" and "skip" validation

                        #306628:
                            RFE: Support xforms:input bound to xs:boolean value

                        #307108:
                            Migrate to recent MSV library

                        #306753:
                            type MIP must support types defined in imported XML schemas

                        #307089:
                            PDF Template processor must not require config input

                        #307093:
                            p:choose should use TinyTree, not dom4j, in order to consume less memory and run faster

                        #307087:
                            Handle case where the initial value for the select1 tree is empty

                        #307073:
                            Group around tr: classes are not correct upon page load

                        #307083:
                            Read-only triggers in Government Forms summary don't work anymore

                        #307082:
                            JavaScript error in some cases when using the upload control with replace="instance"

                        #307064:
                            Instance replacement no longer causes xforms-value-changed to be fired

                        #307059:
                            Read-only instance cannot be submitted

                        #307051:
                            RFE: Select tree: make the currently selected value visible

                        #307046:
                            NPE in XInclude processor

                        #306991:
                            xforms:select1[@appearance="xxforms:tree"] should support updating its structure

                        #306979:
                            Tree does not appear hierarchical when itemset comes from readonly shared instance

                        #306259:
                            RFE: Make xforms:group around xhtml:tr work

                        #307031:
                            Select tree: parent value is considered selected even if not all the children are selected

                        #307030:
                            Items in select tree incorrectly selected

                        #306974:
                            Submission replace="all" is opening a new window in IE

                        #306983:
                            Itemsets are re-evaluated everytime the controls are rebuilt

                        #306982:
                            Orbeon Forms uses Saxon linked tree instead of TinyTree for read-only instances

                        #306971:
                            Delegation processor: Incorrect use of XSLT in example

                        #306969:
                            Calling ORBEON.xforms.Document.setValue with non-existent id causes unexpected JS error

                        #306960:
                            RFE: XSLT transformer should leverage Saxon input document location information

                        #306959:
                            SAXStore only keeps track of a single system ID per document

                        #306958:
                            XInclude processor does not adjust system ID in output locator

                        #306957:
                            Dialog: cursor now showing in text fields on Firefox when multiple dialog in the same page

                        #306728:
                            Tree shouldn't send Ajax requests as you click on it, unless incremental mode is set

                        #306950:
                            XForms: document xxforms:target

                        #306942:
                            XSLT Templates object still indirectly refers to some PipelineContext objects

                        #306919:
                            Submission: can't use serialize="false" with method="post"

                        #306937:
                            theme-plain.xsl must not refer to orbeon.css

                        #306931:
                            Schemas and instance URIs don't resolve against URI of JSP page

                        #306927:
                            Exception with trigger appearance="minimal" and empty label

                        #306911:
                            Group with appearance="xxforms:fieldset" generates xhtml:legend outside xhtml:fieldset

                        #306641:
                            RFE: Integrate "Deploying Orbeon Forms as a separate WebApp" changes

                        #306703:
                            Orbeon 3.5 doesn't compile with Java 6

                        #306897:
                            XPath cache mixes up XPath expressions with AVT expressions

                        #306896:
                            Submission with replace="all" is broken after background upload

                        #306869:
                            Remove handling of xforms-help from themes

                        #306894:
                            Should rename cli-ops.jar to ops-cli.jar for consistency

                        #306859:
                            XForms schema: xsd:any conflicts with xsd:element ref="xsd:schema"

                        #306858:
                            XPL schema is invalid

                <title>Upgrade Notes</title>

                    When upgrading from Orbeon Forms 3.6, please note the following:

                            The following files have been renamed: ops.war to orbeon.war,
                            ops.jar to orbeon.jar, ops-resources-public.jar to
                            orbeon-resources-public.jar, ops-resources-private.jar to
                            orbeon-resources-private.jar

                            We recommend that you update your properties with the following:

                        <xml-source>
                            <comment> Store state on the server </comment>
                            <property as="xs:string" name="oxf.xforms.state-handling" value="server"/>
                        </xml-source>
                        <xml-source>
                            <comment> Allow a maximum of 20 MB of state information among all users </comment>
                            <property as="xs:integer" name="oxf.xforms.store.application.size" value="20000000"/>
                        </xml-source>

                            For more information about configuration, see State Handling.

                            Error resources moved to private location. The files error.xpl and
                            error.xsl under RESOURCES/config have been moved to
                            orbeon-resources-private.jar. If you haven't modified these files, make sure
                            that you remove the old files from RESOURCES/config. If you have made
                            modification, you will have to merge the changes introduced in
                            orbeon-resources-private.jar.

                            Theme CSS stylesheets moved to private location. The files under
                            RESOURCES/config/theme have been moved to
                            orbeon-resources-public.jar. This includes xforms.css and
                            xforms-widgets.css. If you haven't modified these files, make sure that you
                            remove the old files from RESOURCES/config/theme. If you have made
                            modification, you will have to merge the changes introduced in
                            orbeon-resources-public.jar, or better, don't modify these CSS files but
                            override CSS definitions in your own CSS files instead.

                            XML parser upgrade requires XInclude namespace change. The Xerces XML parser has
                            been upgraded to version 2.9. The previous version supported an obsolete version of the
                            XInclude namespace: http://www.w3.org/2003/XInclude. The new version supports
                            the correct namespace as specified by XInclude
                            1.0: http://www.w3.org/2001/XInclude.

                            Note that the correct version has the older year, 2001, instead of the newer
                            year, 2003. If you are using http://www.w3.org/2003/XInclude in
                            your namespace declarations for XInclude, you will need to change these declarations to
                            http://www.w3.org/2001/XInclude.

                            Plain theme no longer copies attributes in XHTML namespace. The plain theme, under
                            RESOURCES/config/theme-plain.xsl, used to convert attributes in the XHTML
                            namespace to attributes in no namespace. If you wrote:

                        <xml-source>

                        </xml-source>

                            then the plain theme would convert this to:

                        <xml-source>

                        </xml-source>

                            There does not seem to be much use for this feature, so for reasons of simplification it
                            was removed. If you do need it then you can add again the following XSLT template:

                        <xml-source>
                             <comment> Copy attributes in XHTML namespace to no namespace </comment>
                             <xsl:template match="@xhtml:*">
                                 <xsl:attribute name="{local-name()}">
                                     <xsl:value-of select="."/>
                                 </xsl:attribute>
                             </xsl:template>
                        </xml-source>

</document>


text:
import {OrgChartConfig} from "./org.chart.config";
import {RenderBoxEventArgs} from "./orgchart.events";

export class OrgChartTemplate {
	public fragment = '';

	public nodeTemplate: string;
	public rightConnectorTemplate: string;
	public leftConnectorTemplate: string;
	public topConnectorTemplate: string;
	public bottomConnectorTemplate: string;
	public horizontalConnectorTemplate: string;
	public definitions: string;

	constructor (private snap: Snap.Paper) {
		this.definitions = '<clipPath id="a"><circle cx="45.17" cy="46.33" r="23.5" fill="none"/></clipPath>';
		this.snap.append(<any>Snap.parse(this.definitions));
		this.snap.select('#a').toDefs();
	}

	private replaceAll(target: string, search: string, replacement: string): string {
		return target.replace(new RegExp(search, 'g'), replacement);
	}

	public collect(args: RenderBoxEventArgs) {
		var tpl = this.replaceAll(this.nodeTemplate, '##x##', args.x + '');
		tpl = this.replaceAll(tpl, '##y##', args.y + '');

		this.fragment += tpl;
	}

	public getTemplateFragment(): any {
		return Snap.parse(this.fragment);
	}
}


text:
package org.axonframework.serialization;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;
import java.util.ServiceLoader;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * Converter implementation that will combine converters to form chains of converters to be able to convert
 * from one type to another, for which there is no suitable single converter.
 *

 * This implementation will also autodetect ContentTypeConverter implementations by scanning
 * {@code /META-INF/services/org.axonframework.serializer.ContentTypeConverter} files on the classpath. These
 * files must contain the fully qualified class names of the implementations to use.
 *
 * @author Allard Buijze
 * @since 2.0
 */
public class ChainingConverter implements Converter {

    private static final Logger logger = LoggerFactory.getLogger(ChainingConverter.class);
    private final List<ContentTypeConverter<?, ?>> converters = new CopyOnWriteArrayList<>();

    /**
     * Initialize a new ChainingConverter. Will autodetect all converters mentioned in
     * {@code /META-INF/services/org.axonframework.serializer.ContentTypeConverter} files on the class path.
     *

     * Instances of ChainingConverter are safe for use in a multi-threaded environment, with exception of the
     * {@link #registerConverter(ContentTypeConverter)} method.
     *
     * @param classLoader the class loader used to load the converters
     */
    public ChainingConverter(ClassLoader classLoader) {
        ServiceLoader<ContentTypeConverter> converterLoader =
                ServiceLoader.load(ContentTypeConverter.class, classLoader);
        for (ContentTypeConverter converter : converterLoader) {
            converters.add(converter);
        }
    }

    @Override
    public boolean canConvert(Class<?> sourceType, Class<?> targetType) {
        if (sourceType.equals(targetType)) {
            return true;
        }
        for (ContentTypeConverter converter : converters) {
            if (canConvert(converter, sourceType, targetType)) {
                return true;
            }
        }
        return ChainedConverter.canConvert(sourceType, targetType, converters);
    }

    @Override
    @SuppressWarnings("unchecked")
    public <T> T convert(Object original, Class<?> sourceType, Class<T> targetType) {
        if (sourceType.equals(targetType)) {
            return (T) original;
        }
        for (ContentTypeConverter converter : converters) {
            if (canConvert(converter, sourceType, targetType)) {
                return (T) converter.convert(original);
            }
        }
        ChainedConverter converter = ChainedConverter.calculateChain(sourceType, targetType, converters);
        converters.add(0, converter);
        return (T) converter.convert(original);
    }

    private <S, T> boolean canConvert(ContentTypeConverter<?, ?> converter, Class<S> sourceContentType,
                                      Class<T> targetContentType) {
        try {
            if (converter.expectedSourceType().isAssignableFrom(sourceContentType) &&
                    targetContentType.isAssignableFrom(converter.targetType())) {
                return true;
            }
            // we do this call to make sure target Type is on the classpath
            converter.targetType();
        } catch (NoClassDefFoundError e) {
            logger.info("ContentTypeConverter [{}] is ignored. It seems to rely on a class that is " +
                                "not available in the class loader: {}", converter, e.getMessage());
            converters.remove(converter);
        }
        return false;
    }

    /**
     * Registers the given {@code converter} with this factory. The converter which is registered last
     * will be inspected first when finding a suitable converter for a given input and output type.
     *

     * An alternative to explicit converter registration (but without the ordering guarantees) is to create a file
     * called {@code org.axonframework.serializer.ContentTypeConverter} in {@code /META-INF/services/} on the
     * class path which contains the fully qualified class names of the converters, separated by newlines. These
     * implementations must have a public no-arg constructor.
     *
     * @param converter the converter to register.
     */
    public void registerConverter(ContentTypeConverter converter) {
        converters.add(0, converter);
    }

    /**
     * Registers a convert of the given {@code converterType} with this factory, only if initialization of such a
     * converter is possible. Both the expected source type and target type classes are checked for availability on the
     * class path. In contrast to {@link #registerConverter(ContentTypeConverter)}, this method allows potentially
     * unsafe (in terms of class dependencies) converters to be registered.
     *

     * The converter which is registered last will be inspected first when finding a suitable
     * converter for a given input and output type.
     *

     * An alternative to explicit converter registration (but without the ordering guarantees) is to create a file
     * called {@code org.axonframework.serializer.ContentTypeConverter} in {@code /META-INF/services/} on the
     * class path which contains the fully qualified class names of the converters, separated by newlines. These
     * implementations must have a public no-arg constructor.
     *
     * @param converterType the type of converter to register.
     */
    public void registerConverter(Class<? extends ContentTypeConverter> converterType) {
        try {
            ContentTypeConverter converter = converterType.getConstructor().newInstance();
            converter.targetType();
            converter.expectedSourceType();
            registerConverter(converter);
        } catch (Exception e) {
            logger.warn("An exception occurred while trying to initialize a [{}].", converterType.getName(), e);
        } catch (NoClassDefFoundError e) {
            logger.info("ContentTypeConverter of type [{}] is ignored. It seems to rely on a class that is " +
                                "not available in the class loader: {}", converterType, e.getMessage());
        }
    }

    /**
     * Setter for dependency injection frameworks that require property methods. This method is the same as calling
     * {@link #registerConverter(ContentTypeConverter)} for each converter in the given list of
     * {@code additionalConverters}.
     *
     * @param additionalConverters The converters to register with this factory
     */
    public void setAdditionalConverters(List<ContentTypeConverter> additionalConverters) {
        additionalConverters.forEach(this::registerConverter);
    }
}


text:
using System;

namespace AjaxControlToolkit {

    // AutoSize provides several options for resizing an Accordion control
    public enum AutoSize {
        // Allow the Accordion to grow as tall as it wants
        None = 0,

        // Force the Accordion to be a specific height
        Fill = 1,

        // Limit the Accordion to a specific height
        Limit = 2
    }

}
#pragma warning restore 1591