text:
using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Scripting.Utils;

namespace Microsoft.Scripting.Actions.Calls {
    public sealed class ApplicableCandidate {
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]
        public readonly MethodCandidate Method;
        public readonly ArgumentBinding ArgumentBinding;

        internal ApplicableCandidate(MethodCandidate method, ArgumentBinding argBinding) {
            Assert.NotNull(method, argBinding);
            Method = method;
            ArgumentBinding = argBinding;
        }

        public ParameterWrapper GetParameter(int argumentIndex) {
            return Method.GetParameter(argumentIndex, ArgumentBinding);
        }

        public override string ToString() {
            return Method.ToString();
        }
    }
}


text:
'use strict';
var React = require('react-native');
var Weather = require('./Weather');
var DrinkName = require('./DrinkName');
var ImageAndIngredients = require('./ImageAndIngredients');
var ShowNextButton = require ('./ShowNextButton');
var Ingredients = require('./Ingredients');
var Recipe = require('./Recipe');
var Dimensions = require('Dimensions');
var windowSize = Dimensions.get('window');
var HeaderLogo = require('./HeaderLogo');

var {
  StyleSheet,
  Text,
  View,
  ActivityIndicatorIOS,
  Image
} = React;

var styles = StyleSheet.create({
  container: {
    flex: 1,
  },
  drinkNameWrapper: {
    flex: 1,
  },
  drinkImageIngredientsWrapper: {
    flex: 4,
  },
  drinkRecipe: {
    flex: 2,
    paddingBottom: 10
  },
  // ingredRecipText: {
  //   color: '#6f0909',
  //   fontFamily: 'Cochin-BoldItalic',
  //   fontSize: 20
  // },

  //     ingredientWrapper: {
  //       flex: 1,
  //       paddingLeft: 10
  //     },
  //     recipeWrapper: {
  //       flex: 1,
  //       paddingRight: 10
  //     },

});

var DrinkDetails = React.createClass({
  render: function(){
    var drinkName = this.props.drink.drinkName;
    var recipe = this.props.drink.recipe
    var ingredients = this.props.drink.ingredients
    var image = this.props.drink.image

    // console.log("in drink Details", ingredients);
    return(
          <View style={[styles.container, this.border('green')]}>

                <View style={[styles.drinkNameWrapper, this.border('pink')]}>
                  <DrinkName drinkName={drinkName} />
                </View>
                <View style={[styles.drinkImageIngredientsWrapper, this.border('blue')]}>
                  <ImageAndIngredients
                  image={image}
                  ingredients={ingredients} />
                </View>
                <View style={[styles.drinkRecipe, this.border('purple')]}>
                  <Recipe recipe={recipe}/>
                </View>

          </View>
          )
  },
  border: function(color){
    return {
      borderColor: color,
      borderWidth: 0
    }
  }
});
module.exports = DrinkDetails;

redpajama_set_name: RedPajamaGithub


text:
namespace Shield.Communication
{
    public class Connection
    {
        public string DisplayName { get; set; }
        public object Source { get; set; }

        public Connection(string displayName, object source)
        {
            this.DisplayName = displayName;
            this.Source = source;
        }
    }
}


text:
<?php

use Trello\Client;

Class Trello {

	public $App;

	protected $user_token = null;

	public function __construct( $App, $user_token=null )
	{
		$this->App = $App;
		$this->user_token = $user_token;
	}

	public function buildURL( $board_id, $user_token )
	{
		return $this->App->trello['api_endpoint_base'] . '/boards/' . $board_id . '?lists=open&list_fields=name&fields=name,desc&key=' . $this->App->trello['app_key'] . '&token=' . $user_token;
	}

	public function addCard( $title, $description, $labels, $board_id, $list_id, $user_token )
	{
		$card_data = array(

			'name'      => $title,
			'desc'      => $description,
			'labels'    => $labels,
			'due'       => null,
			'list_id'   => $list_id,
			'pos'       => 'bottom',

		);

		$endpoint_url = $this->buildURL( $board_id, $user_token );

		$result = $this->sendRequest( $endpoint_url, $card_data, $user_token );

		return $result;
	}

	public function sendRequest( $endpoint_url, $data, $user_token )
	{
		$ch = curl_init();

		// Set query data here with the URL
		curl_setopt( $ch, CURLOPT_URL, $endpoint_url );
		curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, 0 );
		curl_setopt( $ch, CURLOPT_RETURNTRANSFER, 1 );
		curl_setopt( $ch, CURLOPT_TIMEOUT, '25' );

		$content = trim(curl_exec( $ch ));

		curl_close( $ch );

		$board          = json_decode( $content );
		$lists          = $board->lists;
		$trello_list_id = $lists[0]->id;

		foreach ($lists as $list)
		{
			if ($list->id == $data['list_id'])
			{
				$trello_list_id   = $list->id;
				$trello_list_name = $list->name;
			}
		}

		if ( $trello_list_id )
		{

			$ch = curl_init( $this->App->trello['api_endpoint_base'] . "/cards" );

			//
			// Add validation key and token to the post
			//
			$data['key']    = $this->App->trello['app_key'];
			$data['token']  = $user_token;
			$data['idList'] = $trello_list_id;

			curl_setopt_array( $ch, array(

			    CURLOPT_SSL_VERIFYPEER => false,
			    CURLOPT_RETURNTRANSFER => true, 	// So we can get the URL of the newly-created card
			    CURLOPT_POST           => true,

			    //
			    //	If you use an array without being wrapped in http_build_query, the Trello API server won't recognize your POST variables
			    //

			    CURLOPT_POSTFIELDS => http_build_query( $data ),

			));

			$result      = curl_exec( $ch );

			$TrelloCard = json_decode( $result );

			if (empty( $TrelloCard ))
			{
				return "Error adding card: " . $result;
			}

			return ( ($TrelloCard) ? $TrelloCard : false );
		}
		else
		{
			return 'List not found';
		}
	}

	public function getBoards( $trello_user_id, $token=null )
	{
		$_endpoint_url = 'member/' . $trello_user_id . '/boards/';

		if (empty( $token ))
		{
			$token = $this->user_token;
		}

		$TrelloClient = new Client( $this->App->trello['app_key'] );

		$Boards = $TrelloClient->get( $_endpoint_url, array( 'token' => $token ) );

		return $Boards;
	}

	public function getLists( $trello_board_id, $token=null )
	{
		$_endpoint_url = 'boards/' . $trello_board_id . '/lists';

		if (empty( $token ))
		{
			$token = $this->user_token;
		}

		$TrelloClient = new Client( $this->App->trello['app_key'] );

		$Lists = $TrelloClient->get( $_endpoint_url, array( 'token' => $token ) );

		return $Lists;
	}

	public function getLabels( $trello_board_id, $token=null )
	{
		$_endpoint_url = 'boards/' . $trello_board_id . '/labels';

		if (empty( $token ))
		{
			$token = $this->user_token;
		}

		$TrelloClient = new Client( $this->App->trello['app_key'] );

		$Labels = $TrelloClient->get( $_endpoint_url, array( 'token' => $token ) );

		return $Labels;
	}

	public function getMember( $trello_username, $fields=array('username', 'fullName', 'displayName', 'initials') )
	{
		try
		{
			if (!empty( $fields ) && is_array( $fields ))
			{
				foreach ($fields as $value)
				{
					if (empty( $_fields ))
					{
						$_fields = $value;
						continue;
					}

					$_fields .= ',' . $value;
				}

				$fields = $_fields;
			}

			$_endpoint_url = 'member/' . $trello_username;

			$_payload      = array(
				'fields'	=> $fields,
				'boards'	=> 'all'
			);

			$TrelloClient = new Client( $this->App->trello['app_key'] );

			$Member = $TrelloClient->get( $_endpoint_url, $_payload );
		}
		catch (\Exception $e)
		{
			return false;
		}

		return $Member;
	}

	public function getAuthUrl( $app_name )
	{
		$endpoint_url = 'member/dberube';

		$TrelloClient = new Client( $this->App->trello['app_key'] );

		return $TrelloClient->getAuthorizationUrl( $app_name, $this->App->trello['auth_return_url'], array('read', 'write', 'account'), 'never', 'fragment' );
	}
}


text:
var Promise = require('bluebird')
var Issue = require('../database/issue')
var logger = require('console-plus')
var PageUtils = require('./pageUtils.js')
var LayoutTable = require('./components/layoutTable')
module.exports = function (app, passport) {
  app.get('/issues/:issueId', app.isLoggedIn, function (req, res) {
    Promise.try(function () {
      return PageUtils.validateIssueIdParameter(req, res)
    })
    .then(function () {
      var projectPrefix = req.params.issueId.substring(0, req.params.issueId.indexOf('-'))
      var issueSequence = req.params.issueId.substring(req.params.issueId.indexOf('-') + 1, req.params.issueId.length)

      Promise.try(function () {
        return Promise.props(Issue.findIssueForView(projectPrefix, issueSequence))
      }). then(function (issue) {
        var layoutTable = new LayoutTable({columnsPerRow: 3})
        layoutTable.addRow([{label: 'Status', value: issue.status},
                              {label: 'Type', value: issue.type},
                                {label: 'Severity', value: issue.severity}])
        layoutTable.addRow([{label: 'Assignee', value: issue.assignee, href: '/users/' + issue.assignee},
                              {label: 'Reporter', value: issue.reporter, href: '/users/' + issue.reporter}])
        layoutTable.addRow([{label: 'Description', value: issue.description, size: 2}])
        return Promise.all([issue, layoutTable.getHTML()])
      }).spread(function (issue, tableHtml) {
        var specificLinkData = [
          {
            'href': '/editIssue/' + projectPrefix + '-' + issueSequence,
            'label': 'Edit Issue'
          }
        ]
        var headerString = issue.project.prefix + '-' + issue.sequence + ' ' + issue.title
        res.render('viewIssueView.ejs', {
          infoMessages: req.flash('infoMessages'),
          errorMessages: req.flash('errorMessages'),
          user: req.user,
          pageValues: {
            headerTest: headerString,
            table: tableHtml,
            specificLinks: specificLinkData
          }
        })
      })
      .catch(function (err) {
        if (err.stack) {
          logger.error(err.stack)
        } else {
          logger.error(err)
        }
        req.flash('errorMessages', 'Encountered an error while attempting to perform an action')
        res.redirect('/omg')
      })
    })
    .catch(Error, function (err) {
      logger.error(err.stack)
      res.redirect('/404')
    })
  })
}


text:
/* global window, document */

const $ = window.jQuery === undefined ? {} : window.jQuery;

class AdminMenuTabs {

  /**
   * Initalize the Admin Menu Tabs class.
   */
  static init() {
    const adminMenuTabs = new AdminMenuTabs();
    adminMenuTabs.binds();
    adminMenuTabs.setActiveTab();
  }

  /**
   * Bind elements with functions.
   */
  binds() {
    $(document).on('click', '.admin-menu-tab', this.changeTab.bind(this));
    $(document).on('wp-collapse-menu', this.setActiveTab.bind(this));
    $(window).resize(this.resize.bind(this));
  }

  /**
   * Change tab on click.
   *
   * @param {object} $this
   */
  changeTab(e) {
    const $this      = $(e.currentTarget);
    const $adminmenu = $('#adminmenu');
    const $separator = this.getSeparator($adminmenu.find('.wp-menu-separator'));
    const tab        = $this.hasClass('admin-menu-tab-edit') ? 'edit' : 'admin';

    e.preventDefault();

    this.hideMenuItems($separator, tab);

    $.post(window.ajaxurl, {
      action: 'change_admin_menu_tab',
      tab: tab
    });
  }

  /**
   * Reset collapse menu when active tab is hidden.
   *
   * @param  {object} $separator
   */
  hideCollapseMenu($separator) {
    const $collapseMenu = $separator.parent().find('#collapse-menu');
    const $nextAll      = $separator.nextAll();
    $collapseMenu.insertAfter($nextAll.eq($nextAll.length - 2));
  }

  /**
   * Hide menu items.
   *
   * @param {object} $separator
   * @param {string} tab
   */
  hideMenuItems($separator, tab) {
    const $collapseMenu = $separator.parent().find('#collapse-menu');
    const $nextAll      = $separator.nextAll();
    const $prevAll      = $separator.prevAll();

    if (tab === 'edit') {
      $prevAll.show();
      $nextAll.hide();
      $collapseMenu.show().insertAfter($prevAll.first());
      $('.admin-menu-tab-admin').removeClass('active');
      $('.admin-menu-tab-edit').addClass('active');
    } else {
      $prevAll.hide();
      $nextAll.show();
      $collapseMenu.insertAfter($nextAll.eq($nextAll.length - 2));
      $('.admin-menu-tab-admin').addClass('active');
      $('.admin-menu-tab-edit').removeClass('active');
    }

    $separator.hide();
  }

  /**
   * Get separator.
   *
   * @param  {object} $separators
   *
   * @return {object}
   */
  getSeparator($separators) {
    let index = $('#adminmenutabs').data('separator');
    return $separators.eq(index);
  }

  /**
   * Show all menu items when active tab is hidden.
   */
  resize() {
    const $activeTab  = $('.admin-menu-tab.active');
    const $separator  = this.getSeparator($('#adminmenu .wp-menu-separator'));

    if (!$activeTab.is(':visible')) {
      this.hideCollapseMenu($separator);
    } else if (!$('li.menu-top:visible').length) {
      const tab = $activeTab.hasClass('admin-menu-tab-edit') ? 'admin' : 'edit';
      this.hideMenuItems($separator, tab);
    }
  }

  /**
   * Set active tab.
   */
  setActiveTab() {
    const $activeTab = $('.admin-menu-tab.active');
    const $separator = this.getSeparator($('#adminmenu .wp-menu-separator'));
    const url        = window.adminMenuTabs.url;
    const location   = window.location.href.replace(url, '');
    const tab        = $activeTab.hasClass('admin-menu-tab-edit') ? 'edit' : 'admin';

    if (!$activeTab.is(':visible')) {
      this.hideCollapseMenu($separator);
    } else {
      if (location !== '' && $separator.nextAll().find('a[href="' + location + '"]').length) {
        if (location === 'update-core.php') {
          const $menudashboard = $('#menu-dashboard');
          $menudashboard.removeClass('wp-has-current-submenu wp-menu-open').addClass('wp-not-current-submenu');
          $menudashboard.find('a').removeClass('wp-has-current-submenu wp-menu-open');
        }
      }

      this.hideMenuItems($separator, tab);
    }
  }

}

AdminMenuTabs.init();


text:
set -u

# remove old plist
if [[ -f ~/Library/LaunchAgents/osx-launchd-env.plist ]]; then
    rm -f ~/Library/LaunchAgents/osx-launchd-env.plist
fi

# get login shell
login_shell="`dscl localhost -read Local/Default/Users/$USER UserShell | cut -d' ' -f2`"

# get current directory
cwd=$(cd $(dirname $0) && pwd)

# put plist
cp $cwd/osx-launchd-env.plist ~/Library/LaunchAgents

# replace placeholders
/usr/bin/sed -i '' \
    -e "s!{{ SHELL }}!$login_shell!" \
    -e "s!{{ SETENV }}!$cwd/setenv.sh!" \
    ~/Library/LaunchAgents/osx-launchd-env.plist


text:
body.page-changepwd2
{
padding-top:10px; padding-left:10px;
}
.page-changepwd2 .rnr-c-changepwd,
  .rnr-pagewrapper .page-changepwd2 .rnr-c-changepwd,
  .rnr-pagewrapper .rnr-pagewrapper .page-changepwd2 .rnr-c-changepwd
{
margin-bottom:5px;
}
.page-changepwd2 .rnr-c-changepwd,
  .rnr-pagewrapper .page-changepwd2 .rnr-c-changepwd,
  .rnr-pagewrapper .rnr-pagewrapper .page-changepwd2 .rnr-c-changepwd
{
min-width: 500px; display:inline-block
}
.page-changepwd2 .rnr-cw-changepwd,
  .rnr-pagewrapper .page-changepwd2 .rnr-cw-changepwd,
  .rnr-pagewrapper .rnr-pagewrapper .page-changepwd2 .rnr-cw-changepwd
{
text-align: center;
}
.page-changepwd2 .rnr-b-changeheader,
  .rnr-pagewrapper .page-changepwd2 .rnr-b-changeheader,
  .rnr-pagewrapper .rnr-pagewrapper .page-changepwd2 .rnr-b-changeheader
{
white-space: nowrap;
}
.page-changepwd2 .rnr-b-changeheader,
  .rnr-pagewrapper .page-changepwd2 .rnr-b-changeheader,
  .rnr-pagewrapper .rnr-pagewrapper .page-changepwd2 .rnr-b-changeheader
{
text-align: right;
}
.page-changepwd2 .rnr-b-changeheader > *,
  .rnr-pagewrapper .page-changepwd2 .rnr-b-changeheader > *,
  .rnr-pagewrapper .rnr-pagewrapper .page-changepwd2 .rnr-b-changeheader > *
{
font-size: 120%;
}
.page-changepwd2 .rnr-b-message,
  .rnr-pagewrapper .page-changepwd2 .rnr-b-message,
  .rnr-pagewrapper .rnr-pagewrapper .page-changepwd2 .rnr-b-message
{
white-space: nowrap;
}
.page-changepwd2 .rnr-b-message,
  .rnr-pagewrapper .page-changepwd2 .rnr-b-message,
  .rnr-pagewrapper .rnr-pagewrapper .page-changepwd2 .rnr-b-message
{
text-align: right;
}
.page-changepwd2 .rnr-b-message > *,
  .rnr-pagewrapper .page-changepwd2 .rnr-b-message > *,
  .rnr-pagewrapper .rnr-pagewrapper .page-changepwd2 .rnr-b-message > *
{

}
.page-changepwd2 .rnr-c-fields,
  .rnr-pagewrapper .page-changepwd2 .rnr-c-fields,
  .rnr-pagewrapper .rnr-pagewrapper .page-changepwd2 .rnr-c-fields
{
margin-bottom:5px;
}
.page-changepwd2 .rnr-c-fields,
  .rnr-pagewrapper .page-changepwd2 .rnr-c-fields,
  .rnr-pagewrapper .rnr-pagewrapper .page-changepwd2 .rnr-c-fields
{
min-width: 100px;
}
.page-changepwd2 .rnr-b-changefields,
  .rnr-pagewrapper .page-changepwd2 .rnr-b-changefields,
  .rnr-pagewrapper .rnr-pagewrapper .page-changepwd2 .rnr-b-changefields
{
white-space: nowrap;
}
.page-changepwd2 .rnr-b-changefields,
  .rnr-pagewrapper .page-changepwd2 .rnr-b-changefields,
  .rnr-pagewrapper .rnr-pagewrapper .page-changepwd2 .rnr-b-changefields
{
text-align: right;
}
.page-changepwd2 .rnr-b-changefields > *,
  .rnr-pagewrapper .page-changepwd2 .rnr-b-changefields > *,
  .rnr-pagewrapper .rnr-pagewrapper .page-changepwd2 .rnr-b-changefields > *
{

}
.page-changepwd2 .rnr-b-changebuttons,
  .rnr-pagewrapper .page-changepwd2 .rnr-b-changebuttons,
  .rnr-pagewrapper .rnr-pagewrapper .page-changepwd2 .rnr-b-changebuttons
{
white-space: nowrap;
}
.page-changepwd2 .rnr-b-changebuttons,
  .rnr-pagewrapper .page-changepwd2 .rnr-b-changebuttons,
  .rnr-pagewrapper .rnr-pagewrapper .page-changepwd2 .rnr-b-changebuttons
{
text-align: right;
}
.page-changepwd2 .rnr-b-changebuttons > *,
  .rnr-pagewrapper .page-changepwd2 .rnr-b-changebuttons > *,
  .rnr-pagewrapper .rnr-pagewrapper .page-changepwd2 .rnr-b-changebuttons > *
{

}
body.page-changepwd2 .rnr-toptable
{
width:100%;
}
body.page-changepwd2 .rnr-top
{
padding-right: 5px;
}


text:
<?xml version="1.0" encoding="utf-8"?>
<!--
  ~ Copyright (c) 2014, Apptentive, Inc. All Rights Reserved.
  ~ Please refer to the LICENSE file for the terms and conditions
  ~ under which redistribution and use of this file is permitted.
  -->
<resources>
  <string name="apptentive_ok">Okay</string>
  <string name="apptentive_yes">Ja</string>
  <string name="apptentive_no">Nein</string>
  <string name="apptentive_skip">Überspringen</string>
  <string name="apptentive_you">Du</string>
  <string name="apptentive_developer">Entwickler</string>
  <string name="apptentive_oops">Ups!</string>
  <string name="apptentive_send">Senden</string>
  <string name="apptentive_give_feedback">Sende uns dein Feedback</string>
  <string name="apptentive_thanks">Danke!</string>
  <string name="apptentive_no_thanks">Nein, danke</string>
  <string name="apptentive_thank_you">Vielen Dank</string>
  <string name="apptentive_were_sorry">Das tut uns leid!</string>
  <string name="apptentive_required">Erforderlich</string>
  <string name="apptentive_optional">Optional</string>
  <string name="apptentive_sending">Versendung…</string>
  <string name="apptentive_version">Apptentive Version %s</string>
  <string name="apptentive_edittext_hint_email">Deine E-Mail-Adresse</string>
  <string name="apptentive_edittext_hint_email_required">E-Mail-Adresse (erforderlich)</string>
  <string name="apptentive_powered_by_apptentive">Unterstützt von Apptentive</string>
  <string name="apptentive_about_title">Über Apptentive</string>
  <string name="apptentive_about_description">Apptentive  ist ein Feedback- und Kommunikations-Service, der es den Entwicklern dieser App ermöglicht, auf schnelle Weise dein Feedback zu erhalten und besser darauf zu reagieren.</string>
  <string name="apptentive_about_description_link">Mehr Informationen auf apptentive.com</string>
  <string name="apptentive_about_privacy">Dein Feedback wird von Apptentive gehostet und unterliegt der Datenschutzerklärung von Apptentive und der des Entwicklers dieser App.</string>
  <string name="apptentive_about_privacy_link">Zur Datenschutzerklärung von Apptentive</string>
  <string name="apptentive_do_you_love_this_app">Bist du von %s begeistert?</string>
  <string name="apptentive_rating_message_fs">Es freut uns sehr, dass du von %s begeistert bist! Es wäre wirklich hilfreich, wenn du eine Bewertung abgeben würdest. Vielen Dank, dass du deine Zeit mit uns verbringst.</string>
  <string name="apptentive_rate_this_app">%s bewerten</string>
  <string name="apptentive_rating_remind">Später erinnern</string>
  <string name="apptentive_rating_error">Wir konnten die App im Store nicht finden. Besuche bitte den Store, um die App zu finden und zu bewerten.</string>
  <string name="apptentive_intro_dialog_title_no_love">@string/apptentive_were_sorry</string>
  <string name="apptentive_intro_dialog_title_default">Vielen Dank für dein Feedback!</string>
  <string name="apptentive_intro_dialog_body">Lass uns bitte wissen, wie wir %s für dich besser machen können!</string>
  <string name="apptentive_intro_dialog_edittext_hint">Sag uns, wie wir helfen können. (erforderlich)</string>
  <string name="apptentive_thank_you_dialog_body">Deine Antwort wurde in der Mitteilungszentrale gespeichert. Dort kannst du Erwiderungen einsehen und uns weitere Nachrichten senden.</string>
  <string name="apptentive_thank_you_dialog_body_message_center_disabled">Vielen Dank für dein Feedback!</string>
  <string name="apptentive_thank_you_dialog_body_message_center_disabled_email_required">Wir werden uns per E-Mail melden.</string>
  <string name="apptentive_thank_you_dialog_close">Schließen</string>
  <string name="apptentive_thank_you_dialog_view_messages">Nachrichten ansehen</string>
  <string name="apptentive_dialog_email_validation_failed_title">Ungültige E-Mail-Adresse</string>
  <string name="apptentive_dialog_email_validation_failed_body">Gib bitte eine gültige E-Mail-Adresse ein.</string>
  <string name="apptentive_survey_header">Umfrage</string>
  <string name="apptentive_survey_singleline_hint">Antwort eingeben…</string>
  <string name="apptentive_survey_send_response">Antwort senden</string>
  <string name="apptentive_message_center_title">Mitteilungszentrale</string>
  <string name="apptentive_message_center_compose_hint">Nachricht eingeben…</string>
  <string name="apptentive_message_center_attachment_title">Bild senden?</string>
  <string name="apptentive_message_sent_timestamp_format">MMM dd, yyyy h:mma</string>
  <string name="apptentive_message_auto_body_manual">Dies ist unsere Mitteilungszentrale. Wenn du Fragen, Vorschläge oder Bedenken hast oder dich einfach nur melden möchtest, sende uns bitte eine Nachricht. Wir tauschen uns sehr gerne mit unseren Kunden aus!</string>
  <string name="apptentive_message_auto_body_no_love">Was können wir tun, damit dich unsere App begeistert? Wir sind dir für jedes konstruktive Feedback dankbar.</string>
  <string name="apptentive_rating_provider_no_google_play">Google Play nicht gefunden. Bitte installiere Google Play, bevor du diese App bewertest.</string>
  <string name="apptentive_rating_provider_no_amazon_appstore">Amazon App-Shop nicht gefunden. Bitte installiere Amazon App-Shop, bevor du diese App bewertest.</string>
  <string name="apptentive_rating_provider_no_mikandi">MiKandi Market nicht gefunden. Bitte installiere Mikandi Market, bevor du diese App bewertest.</string>
</resources>


text:
package org.apache.nifi.processors.standard;

import org.apache.nifi.serialization.record.MockRecordParser;
import org.apache.nifi.serialization.record.RecordFieldType;
import org.apache.nifi.util.TestRunner;
import org.apache.nifi.util.TestRunners;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;

public class TestPutRecord {

    private TestRunner testRunner;
    private MockRecordParser recordReader;
    private MockRecordSinkService mockRecordSinkService;

    @BeforeEach
    public void setup() {
        PutRecord processor = new PutRecord();
        testRunner = TestRunners.newTestRunner(processor);
        recordReader = new MockRecordParser();
        testRunner.setProperty(PutRecord.RECORD_READER, "reader");
        mockRecordSinkService = new MockRecordSinkService();
        testRunner.setProperty(PutRecord.RECORD_SINK, "MockRecordSinkService");
    }

    @Test
    public void testSimplePut() throws Exception {
        testRunner.addControllerService("reader", recordReader);
        testRunner.enableControllerService(recordReader);

        testRunner.addControllerService("MockRecordSinkService", mockRecordSinkService);
        testRunner.enableControllerService(mockRecordSinkService);

        recordReader.addSchemaField("name", RecordFieldType.STRING);
        recordReader.addSchemaField("age", RecordFieldType.INT);
        recordReader.addSchemaField("sport", RecordFieldType.STRING);

        recordReader.addRecord("John Doe", 48, "Soccer");
        recordReader.addRecord("Jane Doe", 47, "Tennis");
        recordReader.addRecord("Sally Doe", 47, "Curling");
        recordReader.addRecord("Jimmy Doe", 14, null);
        recordReader.addRecord("Pizza Doe", 14, null);

        testRunner.enqueue("");
        testRunner.run();

        testRunner.assertAllFlowFilesTransferred(PutRecord.REL_SUCCESS, 1);
    }

    @Test
    public void testNoRows() throws Exception {
        testRunner.addControllerService("reader", recordReader);
        testRunner.enableControllerService(recordReader);

        testRunner.addControllerService("MockRecordSinkService", mockRecordSinkService);
        testRunner.enableControllerService(mockRecordSinkService);

        testRunner.setProperty(PutRecord.INCLUDE_ZERO_RECORD_RESULTS, "false");

        recordReader.addSchemaField("name", RecordFieldType.STRING);
        recordReader.addSchemaField("age", RecordFieldType.INT);
        recordReader.addSchemaField("sport", RecordFieldType.STRING);

        testRunner.enqueue("");
        testRunner.run();

        assertTrue(mockRecordSinkService.getRows().isEmpty());
        assertFalse(mockRecordSinkService.isTransmitted());
        // Original flow file is still transferred
        testRunner.assertAllFlowFilesTransferred(PutRecord.REL_SUCCESS, 1);
        testRunner.clearTransferState();

        // Send an empty record set anyway
        testRunner.setProperty(PutRecord.INCLUDE_ZERO_RECORD_RESULTS, "true");
        testRunner.enqueue("");
        testRunner.run();

        assertTrue(mockRecordSinkService.getRows().isEmpty());
        assertTrue(mockRecordSinkService.isTransmitted());
        // Original flow file is still transferred
        testRunner.assertAllFlowFilesTransferred(PutRecord.REL_SUCCESS, 1);
    }

    @Test
    public void testBadRecords() throws Exception {
        recordReader = new MockRecordParser(1);
        testRunner.addControllerService("reader", recordReader);
        testRunner.enableControllerService(recordReader);

        testRunner.addControllerService("MockRecordSinkService", mockRecordSinkService);
        testRunner.enableControllerService(mockRecordSinkService);

        recordReader.addSchemaField("name", RecordFieldType.STRING);
        recordReader.addSchemaField("age", RecordFieldType.INT);
        recordReader.addSchemaField("sport", RecordFieldType.STRING);

        recordReader.addRecord("John Doe", 48, "Soccer");
        recordReader.addRecord("Jane Doe", 47, "Tennis");
        recordReader.addRecord("Sally Doe", 47, "Curling");
        recordReader.addRecord("Jimmy Doe", 14, null);
        recordReader.addRecord("Pizza Doe", 14, null);

        testRunner.enqueue("");
        testRunner.run();

        testRunner.assertAllFlowFilesTransferred(PutRecord.REL_FAILURE, 1);
    }

    @Test
    public void testRetryableError() throws Exception {
        recordReader = new MockRecordParser();
        testRunner.addControllerService("reader", recordReader);
        testRunner.enableControllerService(recordReader);

        mockRecordSinkService.setFailWithRetryableError(true);
        testRunner.addControllerService("MockRecordSinkService", mockRecordSinkService);
        testRunner.enableControllerService(mockRecordSinkService);

        recordReader.addSchemaField("name", RecordFieldType.STRING);
        recordReader.addSchemaField("age", RecordFieldType.INT);
        recordReader.addSchemaField("sport", RecordFieldType.STRING);

        recordReader.addRecord("John Doe", 48, "Soccer");

        testRunner.enqueue("");
        testRunner.run();

        testRunner.assertAllFlowFilesTransferred(PutRecord.REL_RETRY, 1);
    }
}


text:
describe('eventDatePicker', function(){
    beforeEach(function(){
        // concerned that fixture is large and involved and creating too complex a seam
        setFixtures('');
    });

    xit('hides event repeat options by default').pend('awaiting refactor of related form for use in fixture');
    xit('shows event repeat options when event is set to repeat').pend('awaiting refactor of related form for use in fixture');
    xit('shows event repeat optional ending when event is set to end').pend('awaiting refactor of related form for use in fixture');
    xit('hides event repeat optional ending when event is set to never end').pend('awaiting refactor of related form for use in fixture');
});


text:
using namespace blink;
using namespace blink::ui;

// --------------------------------------------
// UITextTask
// --------------------------------------------

ui_font_glyph::ui_font_glyph() {
	bearing_x = 0.f;
	bearing_y = 0.f;
	width = 0.f;
	height = 0.f;
	advance = 0.f;
}

ui_font_glyph::~ui_font_glyph() {

}

ui_font::ui_font(ui_string font_filename, ui_render_context* font_context) {
	filename = font_filename;
	render_context = font_context;
}

ui_font::~ui_font() {

}

std::shared_ptr<ui_font_map> ui_font::get_map(uint32_t size) {
	if (key_exists(maps, size)) {
		return maps[size];
	} else {
		return create_map(size);
	}
}

std::shared_ptr<ui_font_map> ui_font::create_map(uint32_t size) {
	auto& map = (maps[size] = std::make_shared<ui_font_map>());
	map->size = size;
	render_context->load_font(this, size);
	return maps[size];
}

// --------------------------------------------
// UITextTask
// --------------------------------------------

void ui_text_task::add_to_job(ui_render_job * job) {
	std::transform(vertieces.begin(), vertieces.end(), job->vertex_vbo->back_inserter(),
		[&](vec2& pos) {
			return vec3(pos, z);
		}
	);

	std::copy(texCoords.begin(), texCoords.end(), job->uv_vbo->back_inserter());

	job->color_vbo->add_range(text_color, vertieces.size());
	job->key_vbo->add_range(font->get_map(size)->key, vertieces.size());
}

ui_text_task::ui_text_task(ui_element* _owner, ui_render_context* _context, ui_render_group* _group) {
	reset_values();

	owner = _owner;
	context = _context;
	visibility = true;
	font = nullptr;
	size = 9;
	z = 0;
	id = 0;
	job_id = 0;
	text_color = color::white;
	group = _group;
}

ui_text_task::~ui_text_task() {

}

ui_text_task::ui_text_task(ui_text_task&& other) {
	id = 0;
	job_id = 0;
	text_color = color::white;

	swap(other);
}

ui_text_task& ui_text_task::operator=(ui_text_task&& other) {
	if (&other != this) {
		swap(other);
	}

	return *this;
}

void ui_text_task::swap(ui_text_task& other) {
	std::swap(vertieces, other.vertieces);
	std::swap(texCoords, other.texCoords);
	std::swap(text, other.text);
	std::swap(font, other.font);
	std::swap(size, other.size);
	std::swap(ignore_linebreaks, other.ignore_linebreaks);
	std::swap(drawing_area, other.drawing_area);
	std::swap(context, other.context);
	std::swap(visibility, other.visibility);
	std::swap(z, other.z);
	std::swap(h_align, other.h_align);
	std::swap(v_align, other.v_align);
	std::swap(text_color, other.text_color);
	std::swap(group, other.group);

	std::swap(id, other.id);
	std::swap(job_id, other.job_id);
}

void ui_text_task::reset_values() {
	drawing_area.position.x = 0;
	drawing_area.position.y = 0;
	drawing_area.size.width = -1;
	drawing_area.size.height = -1;
	text = "";
	font = nullptr;
	size = 9;
	ignore_linebreaks = false;
	text_color = color::white;

	h_align = text_horizontal_alignment::left;
	v_align = text_vertical_alignment::top;

	h_overflow = text_overflow_types::truncate;
	v_overflow = text_overflow_types::truncate;
}

ui_text_task::ui_char_pos_result ui_text_task::can_be_added_to_line(const ui_line& line, const ui_font_glyph& glyph, bool splitWord) {
	if (h_overflow == text_overflow_types::overflow) {
		return ui_char_pos_result::can_be_placed;
	}

	float left = line.pen_x + glyph.bearing_x;
	float top = line.base_line - glyph.bearing_y - glyph.height;
	float right = left + glyph.width;
	float bottom = top + glyph.height;

	if (left > drawing_area.get_right()) {
		if (h_overflow == text_overflow_types::new_line) {
			return ui_char_pos_result::new_line;
		}

		if (h_overflow == text_overflow_types::truncate) {
			return ui_char_pos_result::wait_for_next_line;
		}

		if (h_overflow == text_overflow_types::liberal && splitWord) {
			return ui_char_pos_result::new_line;
		}
	} else {
		return ui_char_pos_result::can_be_placed;
	}

	return ui_char_pos_result::can_be_placed;
}

void ui_text_task::add_char(ui_line& line, const ui_font_glyph& glyph) {
	float left = round(line.pen_x + glyph.bearing_x);
	float right = left + round(glyph.width);

	float bottom = round(line.base_line + (glyph.height - glyph.bearing_y));
	float top = round(bottom - glyph.height);

	vertieces.push_back(vec2(left, bottom + drawing_area.position.y));
	texCoords.push_back(vec2(glyph.texture_rect.position.x, glyph.texture_rect.get_bottom()));

	vertieces.push_back(vec2(right, top + drawing_area.position.y));
	texCoords.push_back(vec2(glyph.texture_rect.get_right(), glyph.texture_rect.position.y));

	vertieces.push_back(vec2(left, top + drawing_area.position.y));
	texCoords.push_back(vec2(glyph.texture_rect.position.x, glyph.texture_rect.position.y));

	vertieces.push_back(vec2(left, bottom + drawing_area.position.y));
	texCoords.push_back(vec2(glyph.texture_rect.position.x, glyph.texture_rect.get_bottom()));

	vertieces.push_back(vec2(right, bottom + drawing_area.position.y));
	texCoords.push_back(vec2(glyph.texture_rect.get_right(), glyph.texture_rect.get_bottom()));

	vertieces.push_back(vec2(right, top + drawing_area.position.y));
	texCoords.push_back(vec2(glyph.texture_rect.get_right(), glyph.texture_rect.position.y));

	line.VertexCount += 6;
	line.pen_x += glyph.advance;
	line.width = line.pen_x - drawing_area.position.x;
}

bool ui_text_task::can_create_new_line(const ui_line& line) {
	auto font_map = font->get_map(size);
	if (v_overflow == text_overflow_types::overflow || v_overflow == text_overflow_types::new_line) {
		return true;
	}

	float newBaseline = line.base_line + font_map->line_height;

	float new_line = 0.f;

	if (v_overflow == text_overflow_types::liberal) {
		new_line = font_map->line_height * 0.5f;
	}

	return newBaseline < drawing_area.get_bottom() + new_line;
}

ui_text_task::ui_line ui_text_task::get_next_line(const ui_line& line) {
	auto font_map = font->get_map(size);
	ui_line nextLine;

	nextLine.base_line = line.base_line + font_map->line_height;
	nextLine.pen_x = drawing_area.position.x;

	return nextLine;
}

void ui_text_task::finish_line(const ui_line& line) {
	if (h_align == text_horizontal_alignment::left) {
		return;
	}

	float offset = 0.f;

	if (h_align == text_horizontal_alignment::center) {
		offset = (drawing_area.size.width - line.width) * 0.5f;
	}

	if (h_align == text_horizontal_alignment::right) {
		offset = drawing_area.size.width - line.width;
	}

	offset = ceil(offset);

	for (std::vector<vec2>::reverse_iterator it = vertieces.rbegin(); it != vertieces.rbegin() + line.VertexCount; ++it) {
		it->x += offset;
	}
}

void ui_text_task::upload() {
	texCoords.clear();
	vertieces.clear();

	// do typo
	if (font != nullptr && visibility) {
		auto font_map = font->get_map(size);
		bool waitForNextLine = false;
		int lineCount = 1;

		ui_line currentLine;
		currentLine.pen_x = drawing_area.position.x;
		currentLine.base_line = font_map->line_ascent;

		for (unsigned char currentChar : text) {

			switch (currentChar) {

			case '\t':
				if (!waitForNextLine) {
					add_char(currentLine, font_map->glyphs['\t']);
				}
				break;

			case '\n':
				if (!ignore_linebreaks || waitForNextLine) {
					if (can_create_new_line(currentLine)) {
						finish_line(currentLine);
						currentLine = get_next_line(currentLine);
						lineCount++;

						waitForNextLine = false;
					} else {
						finish_line(currentLine);
						return;
					}
				}
				break;

			default:
				// ignore control chars
				if (!waitForNextLine) {

					ui_font_glyph glyph = font_map->glyphs[currentChar];

					switch (can_be_added_to_line(currentLine, glyph, true)) {
					case ui_char_pos_result::can_be_placed:
						add_char(currentLine, glyph);
						break;

					case ui_char_pos_result::wait_for_next_line:
						waitForNextLine = true;
						break;

					case ui_char_pos_result::new_line:
						if (can_create_new_line(currentLine)) {
							finish_line(currentLine);
							currentLine = get_next_line(currentLine);
							lineCount++;

							add_char(currentLine, glyph);
						} else {
							finish_line(currentLine);
							return;
						}
						break;
					default:
						break;
					}
				}
				break;
			}
		}

		finish_line(currentLine);

		float overallHeight = lineCount * font_map->line_height;

		if (v_align == text_vertical_alignment::bottom) {
			float offset = ceil(drawing_area.size.height - overallHeight);

			for (std::vector<vec2>::iterator it = vertieces.begin(); it != vertieces.end(); ++it) {
				it->y += offset;
			}
		}

		if (v_align == text_vertical_alignment::center) {
			float offset = ceil((drawing_area.size.height - overallHeight) * 0.5f);

			for (std::vector<vec2>::iterator it = vertieces.begin(); it != vertieces.end(); ++it) {
				it->y += offset;
			}
		}
	}
}

ui_element* ui_text_task::get_owner() const noexcept {
	return owner;
}

uint32_t ui_text_task::get_id() const noexcept {
	return id;
}

uint32_t ui_text_task::get_job_id() const noexcept {
	return job_id;
}

void ui_text_task::set_job_id(uint32_t new_job_id) {
	job_id = new_job_id;
}

rect ui_text_task::get_drawing_area() const noexcept {
	return drawing_area;
}

void ui_text_task::set_drawing_area(rect new_drawing_area) {
	drawing_area = new_drawing_area;
	context->annote_update(this);
}

ui_string ui_text_task::get_text() const noexcept {
	return text;
}

void ui_text_task::set_text(ui_string new_text) {
	text = new_text;
	context->annote_update(this);
}

std::shared_ptr<ui_font> ui_text_task::get_font() const noexcept {
	return font;
}

void ui_text_task::set_font(std::shared_ptr<ui_font> new_font) {
	font = new_font;
	context->annote_update(this);
}

uint32_t ui_text_task::get_size() const noexcept {
	return size;
}

void ui_text_task::set_size(uint32_t new_size) {
	size = new_size;
	context->annote_update(this);
}

bool ui_text_task::get_ignore_linebreaks() const noexcept {
	return ignore_linebreaks;
}

void ui_text_task::set_ignore_linebreaks(bool new_ignore_linebreaks) {
	ignore_linebreaks = new_ignore_linebreaks;
	context->annote_update(this);
}

bool ui_text_task::get_visibility() const noexcept {
	return visibility;
}

void ui_text_task::set_visibility(bool new_visiblity) {
	visibility = new_visiblity;
	context->annote_update(this);
}

uint32_t ui_text_task::get_z() const noexcept {
	return z;
}

void ui_text_task::set_z(uint32_t new_z) {
	z = new_z;
	context->annote_update(this);
}

color ui_text_task::get_color() const noexcept {
	return text_color;
}

void ui_text_task::set_color(color new_text_color) {
	text_color = new_text_color;
	context->annote_update(this);
}

text_horizontal_alignment ui_text_task::get_h_align() const noexcept {
	return h_align;
}

void ui_text_task::set_h_align(text_horizontal_alignment new_h_align) {
	h_align = new_h_align;
	context->annote_update(this);
}

text_vertical_alignment ui_text_task::get_v_align() const noexcept {
	return v_align;
}

void ui_text_task::set_v_align(text_vertical_alignment new_v_align) {
	v_align = new_v_align;
	context->annote_update(this);
}

text_overflow_types ui_text_task::get_h_overflow() const noexcept {
	return h_overflow;
}

void ui_text_task::set_h_overflow(text_overflow_types new_h_overflow) {
	h_overflow = new_h_overflow;
	context->annote_update(this);
}

text_overflow_types ui_text_task::get_v_overflow() const noexcept {
	return v_overflow;
}

void ui_text_task::set_v_overflow(text_overflow_types new_v_overflow) {
	v_overflow = new_v_overflow;
	context->annote_update(this);
}


text:
compress
========

.. automodule:: dataIO.compress
	:members:


text:
#pragma once

#include <inviwo/dataframe/dataframemoduledefine.h>  // for IVW_MODULE_DATAFRAME...

#include <inviwo/core/processors/processor.h>                        // for Processor
#include <inviwo/core/processors/processorinfo.h>                    // for ProcessorInfo
#include <inviwo/dataframe/datastructures/dataframe.h>               // for DataFrameInport, Dat...
#include <inviwo/dataframe/properties/columnmetadatalistproperty.h>  // for ColumnMetaDataListPr...

namespace inviwo {

/** \docpage{org.inviwo.DataFrameMetaData, Data Frame Meta Data}
 * ![](org.inviwo.DataFrameMetaData.png?classIdentifier=org.inviwo.DataFrameMetaData)
 * Augment a DataFrame with column-specific metadata like minimum and maximum values.
 *
 * ### Inports
 *   * __inport__ input DataFrame to be augmented
 *
 * ### Outports
 *   * __outport__ copy of the input DataFrame along with column MetaData
 */
class IVW_MODULE_DATAFRAME_API DataFrameMetaData : public Processor {
public:
    DataFrameMetaData();
    virtual ~DataFrameMetaData() = default;

    virtual void process() override;

    virtual const ProcessorInfo getProcessorInfo() const override;
    static const ProcessorInfo processorInfo_;

private:
    DataFrameInport inport_;
    DataFrameOutport outport_;

    ColumnMetaDataListProperty columns_;
};

}  // namespace inviwo