text:
"""Utilities related to loss functions."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

from tensorflow.python.distribute import distribution_strategy_context
from tensorflow.python.framework import dtypes
from tensorflow.python.framework import ops
from tensorflow.python.keras import backend as K
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import confusion_matrix
from tensorflow.python.ops import control_flow_ops
from tensorflow.python.ops import math_ops
from tensorflow.python.ops import weights_broadcast_ops
from tensorflow.python.util.tf_export import keras_export

@keras_export('keras.losses.Reduction', v1=[])
class ReductionV2(object):
  """Types of loss reduction.

  Contains the following values:

  * `NONE`: Un-reduced weighted losses with the same shape as input.
  * `SUM`: Scalar sum of weighted losses.
  * `SUM_OVER_BATCH_SIZE`: Scalar `SUM` divided by number of elements in losses.
     Note that when using `tf.distribute.Strategy`, this is the global batch
     size across all the replicas that are contributing to a single step.
  """

  NONE = 'none'
  SUM = 'sum'
  SUM_OVER_BATCH_SIZE = 'sum_over_batch_size'

  @classmethod
  def all(cls):
    return (cls.NONE, cls.SUM, cls.SUM_OVER_BATCH_SIZE)

  @classmethod
  def validate(cls, key):
    if key not in cls.all():
      raise ValueError('Invalid Reduction Key %s.' % key)

def squeeze_or_expand_dimensions(y_pred, y_true, sample_weight):
  """Squeeze or expand last dimension if needed.

  1. Squeezes last dim of `y_pred` or `y_true` if their rank differs by 1
  (using `confusion_matrix.remove_squeezable_dimensions`).
  2. Squeezes or expands last dim of `sample_weight` if its rank differs by 1
  from the new rank of `y_pred`.
  If `sample_weight` is scalar, it is kept scalar.

  This will use static shape if available. Otherwise, it will add graph
  operations, which could result in a performance hit.

  Args:
    y_pred: Predicted values, a `Tensor` of arbitrary dimensions.
    y_true: Optional label `Tensor` whose dimensions match `y_pred`.
    sample_weight: Optional weight scalar or `Tensor` whose dimensions match
      `y_pred`.

  Returns:
    Tuple of `y_pred`, `y_true` and `sample_weight`. Each of them possibly has
    the last dimension squeezed,
    `sample_weight` could be extended by one dimension.
  """
  y_pred_shape = y_pred.get_shape()
  y_pred_rank = y_pred_shape.ndims
  if y_true is not None:

    # If sparse matrix is provided as `y_true`, the last dimension in `y_pred`
    # may be > 1. Eg: y_true = [0, 1, 2] (shape=(3,)),
    # y_pred = [[.9, .05, .05], [.5, .89, .6], [.05, .01, .94]] (shape=(3, 3))
    # In this case, we should not try to remove squeezable dimension.
    y_true_shape = y_true.get_shape()
    y_true_rank = y_true_shape.ndims
    if (y_true_rank is not None) and (y_pred_rank is not None):
      # Use static rank for `y_true` and `y_pred`.
      if (y_pred_rank - y_true_rank != 1) or y_pred_shape[-1] == 1:
        y_true, y_pred = confusion_matrix.remove_squeezable_dimensions(
            y_true, y_pred)
    else:
      # Use dynamic rank.
      rank_diff = array_ops.rank(y_pred) - array_ops.rank(y_true)
      squeeze_dims = lambda: confusion_matrix.remove_squeezable_dimensions(  # pylint: disable=g-long-lambda
          y_true, y_pred)
      is_last_dim_1 = math_ops.equal(1, array_ops.shape(y_pred)[-1])
      maybe_squeeze_dims = lambda: control_flow_ops.cond(  # pylint: disable=g-long-lambda
          is_last_dim_1, squeeze_dims, lambda: (y_true, y_pred))
      y_true, y_pred = control_flow_ops.cond(
          math_ops.equal(1, rank_diff), maybe_squeeze_dims, squeeze_dims)

  if sample_weight is None:
    return y_pred, y_true, None

  sample_weight = ops.convert_to_tensor(sample_weight)
  weights_shape = sample_weight.get_shape()
  weights_rank = weights_shape.ndims
  if weights_rank == 0:  # If weights is scalar, do nothing.
    return y_pred, y_true, sample_weight

  if (y_pred_rank is not None) and (weights_rank is not None):
    # Use static rank.
    if weights_rank - y_pred_rank == 1:
      sample_weight = array_ops.squeeze(sample_weight, [-1])
    elif y_pred_rank - weights_rank == 1:
      sample_weight = array_ops.expand_dims(sample_weight, [-1])
    return y_pred, y_true, sample_weight

  # Use dynamic rank.
  weights_rank_tensor = array_ops.rank(sample_weight)
  rank_diff = weights_rank_tensor - array_ops.rank(y_pred)
  maybe_squeeze_weights = lambda: array_ops.squeeze(sample_weight, [-1])

  def _maybe_expand_weights():
    return control_flow_ops.cond(
        math_ops.equal(rank_diff,
                       -1), lambda: array_ops.expand_dims(sample_weight, [-1]),
        lambda: sample_weight)

  def _maybe_adjust_weights():
    return control_flow_ops.cond(
        math_ops.equal(rank_diff, 1), maybe_squeeze_weights,
        _maybe_expand_weights)

  # squeeze or expand last dim of `sample_weight` if its rank differs by 1
  # from the new rank of `y_pred`.
  sample_weight = control_flow_ops.cond(
      math_ops.equal(weights_rank_tensor, 0), lambda: sample_weight,
      _maybe_adjust_weights)
  return y_pred, y_true, sample_weight

def _safe_mean(losses, num_present):
  """Computes a safe mean of the losses.

  Args:
    losses: `Tensor` whose elements contain individual loss measurements.
    num_present: The number of measurable elements in `losses`.

  Returns:
    A scalar representing the mean of `losses`. If `num_present` is zero,
      then zero is returned.
  """
  total_loss = math_ops.reduce_sum(losses)
  return math_ops.div_no_nan(total_loss, num_present, name='value')

def _num_elements(losses):
  """Computes the number of elements in `losses` tensor."""
  with ops.name_scope(None, 'num_elements', values=[losses]) as scope:
    return math_ops.cast(array_ops.size(losses, name=scope), dtype=losses.dtype)

def reduce_weighted_loss(weighted_losses,
                         reduction=ReductionV2.SUM_OVER_BATCH_SIZE):
  """Reduces the individual weighted loss measurements."""
  if reduction == ReductionV2.NONE:
    loss = weighted_losses
  else:
    loss = math_ops.reduce_sum(weighted_losses)
    if reduction == ReductionV2.SUM_OVER_BATCH_SIZE:
      num_replicas = (  # Used to convert from local to global batch size.
          distribution_strategy_context.get_strategy().num_replicas_in_sync)
      loss = _safe_mean(loss, num_replicas * _num_elements(weighted_losses))
  return loss

def compute_weighted_loss(losses,
                          sample_weight=None,
                          reduction=ReductionV2.SUM_OVER_BATCH_SIZE,
                          name=None):
  """Computes the weighted loss.

  Args:
    losses: `Tensor` of shape `[batch_size, d1, ... dN]`.
    sample_weight: Optional `Tensor` whose rank is either 0, or the same rank as
      `losses`, or be broadcastable to `losses`.
    reduction: (Optional) Type of `tf.keras.losses.Reduction` to apply to loss.
      Default value is `SUM_OVER_BATCH_SIZE`.
    name: Optional name for the op.

  Raises:
    ValueError: If the shape of `sample_weight` is not compatible with `losses`.

  Returns:
    Weighted loss `Tensor` of the same type as `losses`. If `reduction` is
    `NONE`, this has the same shape as `losses`; otherwise, it is scalar.
  """
  ReductionV2.validate(reduction)
  if sample_weight is None:
    sample_weight = 1.0
  with ops.name_scope(name, 'weighted_loss', (losses, sample_weight)):
    # Update dimensions of `sample_weight` to match with `losses` if possible.
    losses, _, sample_weight = squeeze_or_expand_dimensions(
        losses, None, sample_weight)
    losses = ops.convert_to_tensor(losses)
    input_dtype = losses.dtype
    losses = math_ops.cast(losses, dtypes.float32)
    sample_weight = math_ops.cast(sample_weight, dtypes.float32)

    try:
      # Broadcast weights if possible.
      sample_weight = weights_broadcast_ops.broadcast_weights(
          sample_weight, losses)
    except ValueError:
      # Reduce values to same ndim as weight array.
      ndim = K.ndim(losses)
      weight_ndim = K.ndim(sample_weight)
      losses = K.mean(losses, axis=list(range(weight_ndim, ndim)))

    sample_weight.get_shape().assert_is_compatible_with(losses.get_shape())
    weighted_losses = math_ops.multiply(losses, sample_weight)
    # Apply reduction function to the individual weighted losses.
    loss = reduce_weighted_loss(weighted_losses, reduction)
    # Convert the result back to the input type.
    loss = math_ops.cast(loss, input_dtype)
    return loss

def scale_loss_for_distribution(loss_value):
  """Scales and returns the given loss value by the number of replicas."""
  num_replicas = (
      distribution_strategy_context.get_strategy().num_replicas_in_sync)
  if num_replicas > 1:
    loss_value *= (1. / num_replicas)
  return loss_value


text:
package com.thoughtworks.go.server.web;

import com.google.gson.JsonObject;
import com.thoughtworks.go.server.service.BackupService;
import com.thoughtworks.go.server.util.ServletHelper;
import com.thoughtworks.go.util.FileUtil;
import org.eclipse.jetty.http.HttpMethod;
import org.eclipse.jetty.http.HttpURI;
import org.eclipse.jetty.server.HttpChannel;
import org.eclipse.jetty.server.HttpInput;
import org.eclipse.jetty.server.Request;
import org.junit.Before;
import org.junit.Test;

import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;

import static org.mockito.Mockito.*;

public class BackupFilterTest {

    private HttpServletResponse res;
    private BackupFilter backupFilter;
    private static final String BACKUP_STARTED_AT = "Some old date";
    private static final String BACKUP_STARTED_BY = "admin";
    private FilterChain chain;
    private FilterConfig filterConfig;
    private BackupService backupService;
    private PrintWriter writer;
    private InputStream inputStream;

    @Before
    public void setUp() throws ServletException, IOException {
        ServletHelper.init();

        res = mock(HttpServletResponse.class);
        backupService = mock(BackupService.class);
        chain = mock(FilterChain.class);
        filterConfig = mock(FilterConfig.class);
        inputStream = BackupFilter.class.getClassLoader().getResourceAsStream("backup_in_progress.html");
        writer = mock(PrintWriter.class);
        when(res.getWriter()).thenReturn(writer);
        this.backupFilter = new BackupFilter(backupService);
        backupFilter.init(filterConfig);
    }

    @Test
    public void shouldPassRequestWhenBackupIsNotBeingTaken() throws Exception {
        when(backupService.isBackingUp()).thenReturn(false);
        Request request = request(HttpMethod.GET, "", "/go/agents");
        backupFilter.doFilter(request, res, chain);
        verify(res, times(0)).setContentType("text/html");
        verify(writer, times(0)).print("some test data for my input stream");
    }

    @Test
    public void shouldWriteToResponseWhenBackupIsBeingTaken() throws Exception {
        when(backupService.isBackingUp()).thenReturn(true);
        when(backupService.backupRunningSinceISO8601()).thenReturn(BACKUP_STARTED_AT);
        when(backupService.backupStartedBy()).thenReturn(BACKUP_STARTED_BY);

        String content = FileUtil.readToEnd(inputStream);
        content = backupFilter.replaceStringLiterals(content);
        Request request = request(HttpMethod.GET, "", "/go/agents");

        backupFilter.doFilter(request, res, chain);

        verify(res, times(1)).setContentType("text/html");
        verify(writer).print(content);
        verify(res).setHeader("Cache-Control", "private, max-age=0, no-cache");
        verify(res).setDateHeader("Expires", 0);
    }

    @Test
    public void shouldGenerateHTMLResponseWhenBackupIsBeingTakenAndMessageJsonIsCalled() throws Exception {
        when(backupService.isBackingUp()).thenReturn(true);
        when(backupService.backupRunningSinceISO8601()).thenReturn(BACKUP_STARTED_AT);
        when(backupService.backupStartedBy()).thenReturn(BACKUP_STARTED_BY);

        String content = FileUtil.readToEnd(inputStream);
        content = backupFilter.replaceStringLiterals(content);
        Request request = request(HttpMethod.GET, "", "/go/server/messages.json");

        backupFilter.doFilter(request, res, chain);

        verify(res, times(1)).setContentType("text/html");
        verify(writer).print(content);
        verify(res).setHeader("Cache-Control", "private, max-age=0, no-cache");
        verify(res).setDateHeader("Expires", 0);
    }

    @Test
    public void shouldReturnJsonResponseWhenBackupIsFinishedJsonAPIIsBeingCalled() throws Exception {
        when(backupService.isBackingUp()).thenReturn(true);
        when(backupService.backupRunningSinceISO8601()).thenReturn(BACKUP_STARTED_AT);
        when(backupService.backupStartedBy()).thenReturn(BACKUP_STARTED_BY);
        Request request = request(HttpMethod.GET, "application/json", "/go/is_backup_finished.json");

        backupFilter.doFilter(request, res, chain);

        verify(res, times(1)).setContentType("application/json");
        JsonObject json = new JsonObject();
        json.addProperty("is_backing_up", true);
        verify(writer).print(json);
        verify(res).setHeader("Cache-Control", "private, max-age=0, no-cache");
        verify(res).setDateHeader("Expires", 0);
    }

    @Test
    public void shouldReturn503WhenJsonAPICallIsMadeAndBackupBeingTaken() throws Exception {
        when(backupService.isBackingUp()).thenReturn(true);
        when(backupService.backupRunningSinceISO8601()).thenReturn(BACKUP_STARTED_AT);
        when(backupService.backupStartedBy()).thenReturn(BACKUP_STARTED_BY);
        Request request = request(HttpMethod.GET, "application/json", "/go/api/agents");

        backupFilter.doFilter(request, res, chain);

        verify(res, times(1)).setContentType("application/json");
        JsonObject json = new JsonObject();
        assertResponse(json);
    }

    @Test
    public void shouldReturn503WhenXMLAPICallIsMadeAndBackupBeingTaken() throws Exception {
        when(backupService.isBackingUp()).thenReturn(true);
        when(backupService.backupRunningSinceISO8601()).thenReturn(BACKUP_STARTED_AT);
        when(backupService.backupStartedBy()).thenReturn(BACKUP_STARTED_BY);
        Request request = request(HttpMethod.GET, "application/json", "/go/api/config.xml");

        backupFilter.doFilter(request, res, chain);

        verify(res, times(1)).setContentType("application/json");
        JsonObject json = new JsonObject();
        assertResponse(json);
    }

    private void assertResponse(JsonObject json) {
        json.addProperty("message", "Server is under maintenance mode, please try later.");
        verify(writer).print(json);
        verify(res).setHeader("Cache-Control", "private, max-age=0, no-cache");
        verify(res).setDateHeader("Expires", 0);
    }

    private Request request(HttpMethod method, String contentType, String uri) {
        Request request = new Request(mock(HttpChannel.class), mock(HttpInput.class));
        request.setContentType(contentType);
        request.setMethod(method, method.asString());
        request.setUri(new HttpURI(uri));
        return request;
    }
}

redpajama_set_name: RedPajamaGithub


text:
class CreateUserFriends < ActiveRecord::Migration
  def change
    create_table :user_friends do |t|
      t.integer :user_id
      t.integer :friend_id, foreign_key: { references: :users }

      t.timestamps
    end

    add_index :user_friends, [:user_id, :friend_id], unique: true
  end
end


text:
/**
 * Configures for express
 */
var express = require( 'express' );

module.exports = function( app ){

   // Use the ejs templatiing engine
   app.engine('.ejs', require('ejs').__express);
   app.set('views', __dirname + '/../views');
   app.set('view engine', 'ejs');

   // Allow proxy servers from localhost only
   app.set('trust proxy', ['loopback']);

   // Allow post requests off up to 512MB
   app.use(express.bodyParser({limit: '512mb'}));

   // All overriding over content-type so
   // IE8 can set content type to JSON
   // Stupid IE...
   app.use(function (req, res, next) {
      if( req.method != 'POST' )
         return next();
      if( req.param('content-type') != void(0) )
         req.headers['content-type'] = req.param('content-type');
      next();
   });

   // Set the CORS headers always
   app.use(function (req, res, next) {
      res.setHeader('Access-Control-Allow-Origin', '*');
      res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
      res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
      next();
   });

   app.use(express.bodyParser());
   app.use(app.router);

   // Allows Express URL paramaters to accept regex
   app.param(function(name, fn){
     if (fn instanceof RegExp) {
       return function(req, res, next, val){
         var captures = fn.exec(String(val));
         if (captures) {
           req.params[name] = captures;
           next();
         } else {
           next('route');
         }
       };
     }
   });

   // Set the location of static content
   app.use(express.static(root + '/public'));

   // Set the default error handler
   app.use( express.errorHandler() );
};


text:
package com.gazbert.bxbot.datastore.yaml.strategy;

import com.gazbert.bxbot.domain.strategy.StrategyConfig;
import java.util.ArrayList;
import java.util.List;

/**
 * Wraps a list of Strategy configs for dumping to and loading from YAML.
 *
 * @author gazbert
 */
public class StrategiesType {

  private List<StrategyConfig> strategies;

  /** Returns the Strategy configs. */
  public List<StrategyConfig> getStrategies() {
    if (strategies == null) {
      strategies = new ArrayList<>();
    }
    return strategies;
  }

  public void setStrategies(List<StrategyConfig> strategies) {
    this.strategies = strategies;
  }
}


text:
<?php

namespace Oro\Bundle\CalendarBundle\Tests\Functional\Controller;

use Oro\Bundle\ActivityBundle\Form\DataTransformer\ContextsToViewTransformer;
use Oro\Bundle\TestFrameworkBundle\Test\WebTestCase;
use Oro\Bundle\UserBundle\Entity\User;

class CalendarEventControllerTest extends WebTestCase
{
    protected function setUp(): void
    {
        $this->initClient([], $this->generateBasicAuthHeader());
        $this->client->useHashNavigation(true);
        $this->loadFixtures(['Oro\Bundle\UserBundle\Tests\Functional\DataFixtures\LoadUserData']);
    }

    public function testIndex()
    {
        $crawler = $this->client->request('GET', $this->getUrl('oro_calendar_event_index'));
        $result  = $this->client->getResponse();
        $this->assertHtmlResponseStatusCodeEquals($result, 200);
        $this->assertEquals('Calendar Events - Activities', $crawler->filter('#page-title')->html());
    }

    /**
     * @return array
     */
    public function testCreateAction()
    {
        $crawler = $this->client->request('GET', $this->getUrl('oro_calendar_event_create'));
        $form    = $crawler->selectButton('Save and Close')->form();
        $user    = $this->getReference('simple_user');
        $admin   = $this->getAdminUser();

        $form['oro_calendar_event_form[title]']       = 'test title extra unique title';
        $form['oro_calendar_event_form[description]'] = 'test description';
        $form['oro_calendar_event_form[start]']       = '2016-05-23T14:46:02Z';
        $form['oro_calendar_event_form[end]']         = '2016-05-23T15:46:02Z';
        $form['oro_calendar_event_form[attendees]']   = implode(
            ContextsToViewTransformer::SEPARATOR,
            [
                json_encode([
                    'entityClass' => get_class($user),
                    'entityId' => $user->getId(),
                ]),
                json_encode([
                    'entityClass' => get_class($admin),
                    'entityId' => $admin->getId(),
                ])
            ]
        );

        $this->client->followRedirects(true);
        $crawler = $this->client->submit($form);

        $result = $this->client->getResponse();
        $this->assertHtmlResponseStatusCodeEquals($result, 200);
        static::assertStringContainsString('Calendar event saved', $crawler->html());

        $attendees = $this->getContainer()->get('doctrine')
            ->getRepository('OroCalendarBundle:Attendee')
            ->findAll();
        $this->assertCount(2, $attendees);

        $attendeesId = [];
        foreach ($attendees as $attendee) {
            $attendeesId[] = $attendee->getId();
        }

        $calendarEvent = $this->getContainer()->get('doctrine')
            ->getRepository('OroCalendarBundle:CalendarEvent')
            ->findOneBy(['title' => 'test title extra unique title']);

        return [
            'calendarId' => $calendarEvent->getId(),
            'attendees'  => $attendeesId
        ];
    }

    /**
     * @depends testCreateAction
     */
    public function testViewAction(array $param)
    {
        $this->client->request(
            'GET',
            $this->getUrl('oro_calendar_event_view', ['id' => $param['calendarId']])
        );
        $result  = $this->client->getResponse();
        $this->assertHtmlResponseStatusCodeEquals($result, 200);
    }

    /**
     * @depends testCreateAction
     */
    public function testUpdateAction(array $param)
    {
        $response = $this->client->requestGrid(
            'calendar-event-grid',
            ['calendar-event-grid[_filter][title][value]' => 'test title extra unique title']
        );
        $result = $this->getJsonResponseContent($response, 200);
        $result = reset($result['data']);

        $crawler = $this->client->request(
            'GET',
            $this->getUrl('oro_calendar_event_update', ['id' => $result['id']])
        );
        $form    = $crawler->selectButton('Save and Close')->form();

        $form['oro_calendar_event_form[title]']       = 'test title';
        $form['oro_calendar_event_form[description]'] = 'test description';
        $form['oro_calendar_event_form[start]']       = '2016-05-23T14:46:02Z';
        $form['oro_calendar_event_form[end]']         = '2016-05-23T15:46:02Z';
        $form['oro_calendar_event_form[attendees]']   = implode(
            ContextsToViewTransformer::SEPARATOR,
            [
                json_encode([
                    'entityClass' => 'Oro\Bundle\CalendarBundle\Entity\Attendee',
                    'entityId' => $param['attendees'][0],
                ]),
                json_encode([
                    'entityClass' => 'Oro\Bundle\CalendarBundle\Entity\Attendee',
                    'entityId' => $param['attendees'][1],
                ])
            ]
        );

        $this->client->followRedirects(true);
        $crawler = $this->client->submit($form);

        $result = $this->client->getResponse();
        $this->assertHtmlResponseStatusCodeEquals($result, 200);
        static::assertStringContainsString('Calendar event saved', $crawler->html());

        $attendees = $this->getContainer()->get('doctrine')
            ->getRepository('OroCalendarBundle:Attendee')
            ->findAll();
        $this->assertCount(2, $attendees);

        foreach ($attendees as $attendee) {
            $this->assertTrue(
                in_array($attendee->getId(), $param['attendees'])
            );
        }
    }

    /**
     * @return User
     */
    protected function getAdminUser()
    {
        return $this->getContainer()->get('doctrine')
            ->getRepository('OroUserBundle:User')
            ->findOneByEmail('admin@example.com');
    }
}


text:
# gwt-material-errai
Basic Errai application integrated with GMD

# Information of the POC
- Uses Java 8
- Uses GWT 2.8-SNAPSHOT
- Uses Errai 4.0.0-beta1
- Shows how GMD works with Errai's DataBinding
- HOW GMD Templating works with Errai
- Supports Superdev mode for real time development


text:
using org.ohdsi.cdm.framework.common.Builder;
using org.ohdsi.cdm.framework.common.Extensions;
using org.ohdsi.cdm.framework.common.Omop;
using System.Collections.Generic;
using System.Data;
using System.Globalization;
using System.Linq;

namespace org.ohdsi.cdm.framework.common.Definitions
{
    public class CareSiteDefinition : EntityDefinition
    {
        public string LocationId { get; set; }
        public string Location { get; set; }
        public string Name { get; set; }
        public string PlaceOfSvcSourceValue { get; set; }
        public string PlaceOfSvcConceptId { get; set; }
        public string CareSiteSourceValue { get; set; }

        public override IEnumerable<IEntity> GetConcepts(Concept concept, IDataRecord reader,
            KeyMasterOffsetManager offset)
        {
            var id = string.IsNullOrEmpty(Id) ? -1 : reader.GetLong(Id);
            int conceptId = 0;
            if (!string.IsNullOrEmpty(PlaceOfSvcConceptId) && reader.GetLong(PlaceOfSvcConceptId).HasValue)
            {
                conceptId = reader.GetInt(PlaceOfSvcConceptId).Value;
            }

            var locationId = reader.GetLong(LocationId);
            if (!locationId.HasValue)
            {
                var locationSourceValue = reader.GetString(Location);
                if (!string.IsNullOrEmpty(Location))
                {
                    locationId = Entity.GetId(locationSourceValue);
                }
            }

            var careSiteSourceValue = string.IsNullOrEmpty(CareSiteSourceValue)
                ? id.Value.ToString(CultureInfo.InvariantCulture)
                : reader.GetString(CareSiteSourceValue);

            if (concept == null)
            {
                var cs = new CareSite
                {
                    LocationId = locationId ?? 0,
                    PlaceOfSvcSourceValue = reader.GetString(PlaceOfSvcSourceValue),
                    ConceptId = conceptId,
                    Name = reader.GetString(Name),
                    SourceValue = careSiteSourceValue
                };

                if (id.Value == -1)
                {
                    id = Entity.GetId(cs.GetKey());
                }

                cs.Id = id.Value;

                yield return cs;
            }
            else
            {
                var conceptField = concept.Fields[0];

                var source = reader.GetString(conceptField.Key) ?? reader.GetString(conceptField.SourceKey);
                if (source != null && source.Length == 0)
                    source = null;

                var placeOfSvcConceptIds = concept.GetConceptIdValues(Vocabulary, conceptField, reader).ToList();
                int? placeOfSvcConceptId = null;

                int defaultConceptId = 0;
                if (conceptField.DefaultConceptId.HasValue)
                {
                    defaultConceptId = conceptField.DefaultConceptId.Value;
                }

                if (placeOfSvcConceptIds.Count > 0 && placeOfSvcConceptIds[0].ConceptId != 0)
                {
                    placeOfSvcConceptId = placeOfSvcConceptIds[0].ConceptId;
                }

                var cs = new CareSite
                {
                    LocationId = locationId ?? 0,
                    PlaceOfSvcSourceValue = source,
                    ConceptId = placeOfSvcConceptId ?? defaultConceptId,
                    Name = reader.GetString(Name),
                    SourceValue = careSiteSourceValue
                };

                if (id.Value == -1)
                {
                    id = Entity.GetId(cs.GetKey());
                }

                cs.Id = id.Value;

                yield return cs;
            }
        }
    }
}


text:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Web;
using Orchard.ContentManagement;

namespace Liveo.Platform.Models
{
    public class MediaCollectionPart : ContentPart<MediaCollectionPartRecord>
    {
        [DisplayName("Media Collection ID")]
        public int MediaCollectionId {
            get { return Record.MediaCollectionId; }
            set { Record.MediaCollectionId = value; }
        }
    }
}


text:
// Torsion TorqueScript IDE - Copyright (C) Sickhead Games, LLC
// This file is subject to the terms and conditions defined in
// file 'LICENSE.txt', which is part of this source code package.

#ifndef _FINDINFILESDLG_H_
#define _FINDINFILESDLG_H_

#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "FindInFilesDlg.cpp"
#endif

/*!
 * Includes
 */

////@begin includes
////@end includes

/*!
 * Forward declarations
 */

class FindThread;

////@begin forward declarations
////@end forward declarations

/*!
 * Control identifiers
 */

////@begin control identifiers
#define SYMBOL_FINDINFILESDLG_STYLE wxCAPTION|wxSYSTEM_MENU|wxCLOSE_BOX
#define SYMBOL_FINDINFILESDLG_TITLE _("Find in Files")
#define SYMBOL_FINDINFILESDLG_IDNAME wxID_ANY
#define SYMBOL_FINDINFILESDLG_SIZE wxSize(266, 184)
#define SYMBOL_FINDINFILESDLG_POSITION wxDefaultPosition
#define ffID_BROWSE 10012
#define ffID_MATCHCASE 10013
#define ffID_WHOLEWORD 10014
////@end control identifiers

/*!
 * Compatibility
 */

#ifndef wxCLOSE_BOX
#define wxCLOSE_BOX 0x1000
#endif
#ifndef wxFIXED_MINSIZE
#define wxFIXED_MINSIZE 0
#endif

/*!
 * FindInFilesDlg class declaration
 */

class FindInFilesDlg: public wxDialog
{
    DECLARE_DYNAMIC_CLASS( FindInFilesDlg )
    DECLARE_EVENT_TABLE()

public:
    /// Constructors
    FindInFilesDlg();
    FindInFilesDlg( wxWindow* parent, wxWindowID id = SYMBOL_FINDINFILESDLG_IDNAME, const wxString& caption = SYMBOL_FINDINFILESDLG_TITLE, const wxPoint& pos = SYMBOL_FINDINFILESDLG_POSITION, const wxSize& size = SYMBOL_FINDINFILESDLG_SIZE, long style = SYMBOL_FINDINFILESDLG_STYLE );

    /// Creation
    bool Create( wxWindow* parent, wxWindowID id = SYMBOL_FINDINFILESDLG_IDNAME, const wxString& caption = SYMBOL_FINDINFILESDLG_TITLE, const wxPoint& pos = SYMBOL_FINDINFILESDLG_POSITION, const wxSize& size = SYMBOL_FINDINFILESDLG_SIZE, long style = SYMBOL_FINDINFILESDLG_STYLE );

    /// Creates the controls and sizers
    void CreateControls();

////@begin FindInFilesDlg event handler declarations

    /// wxEVT_COMMAND_BUTTON_CLICKED event handler for ffID_BROWSE
    void OnBrowseClick( wxCommandEvent& event );

    /// wxEVT_COMMAND_BUTTON_CLICKED event handler for wxID_OK
    void OnFindClick( wxCommandEvent& event );

    /// wxEVT_UPDATE_UI event handler for wxID_OK
    void OnFindUpdate( wxUpdateUIEvent& event );

////@end FindInFilesDlg event handler declarations

////@begin FindInFilesDlg member function declarations

    /// Retrieves bitmap resources
    wxBitmap GetBitmapResource( const wxString& name );

    /// Retrieves icon resources
    wxIcon GetIconResource( const wxString& name );
////@end FindInFilesDlg member function declarations

    void AddLookIn( const wxString& path );
    void AddWhat( const wxString& what );
    void AddType( const wxString& type );

    wxArrayString GetPathsFromLookIn( const wxString& lookin ) const;

    wxString GetWhat() const;
    wxString GetLookIn() const;
    wxString GetTypes() const;

    FindThread* m_FindThread;

    /// Should we show tooltips?
    static bool ShowToolTips();

////@begin FindInFilesDlg member variables
    wxComboBox* m_WhatCtrl;
    wxComboBox* m_LookInCtrl;
    wxComboBox* m_TypeCtrl;
    wxCheckBox* m_MatchCaseCtrl;
    wxCheckBox* m_WholeWordCtrl;
////@end FindInFilesDlg member variables
};

#endif
    // _FINDINFILESDLG_H_


text:
<resources>

    <!-- Declare custom theme attributes that allow changing which styles are
         used for button bars depending on the API level.
         ?android:attr/buttonBarStyle is new as of API 11 so this is
         necessary to support previous API levels. -->
    <declare-styleable name="ButtonBarContainerTheme">
        <attr name="metaButtonBarStyle" format="reference" />
        <attr name="metaButtonBarButtonStyle" format="reference" />
    </declare-styleable>

    <declare-styleable name="StaticMapView">
        <attr name="aspectRatio" format="float|reference" />
    </declare-styleable>

    <declare-styleable name="AvatarImageBehavior">
        <attr name="finalYPosition" format="dimension" />
        <attr name="startXPosition" format="dimension" />
        <attr name="startToolbarPosition" format="dimension" />
        <attr name="startHeight" format="dimension" />
        <attr name="finalHeight" format="dimension" />
    </declare-styleable>

</resources>


text:
/**
 * Service that configures policy aspects of the KnAllEdge system
 * @class McmMapPolicyService
 * @memberof knalledge.knalledgeMap
*/

export class McmMapPolicyService {
  private provider: any = {
    config: {
      broadcasting: {
          enabled: false, //broaadcasting toward receviers
          receiveNavigation: true, //going through map (changing selected nodes), ...
          receiveStructural: true, //knawledge management (creation, delete, ....)
          receiveVisualization: true, //changes in view settings (showInages, showNodeTypes, limit range of visible nodes, IBIS, etc)
          receiveBehaviours: true, //receive changes in behaviours/modes (broadcasting, etc)
      },
      moderating: {
          enabled: false
      },
      behaviour: {
          brainstorming: 0 //0:off, 1:phase 1; ... 4:phase 4
      },
      state: {
        id: 0,
        name: ""
        // id: 1,
        // name: "CollaboArthon"
      },
      mediation: {
        sendRequest: true
      }
    }
  };

  get():any {
      return this.provider;
  }
}


text:
/* Generated from es-ES.po at Mon 14 May 2012 15:09 */
window.ui_strings || (window.ui_strings  = {});
window.ui_strings.lang_code = "es-ES";
ui_strings.S_ANONYMOUS_FUNCTION_NAME="<función anónima>";
ui_strings.S_BUTTON_CANCEL="Cancelar";
ui_strings.S_BUTTON_CANCEL_REMOTE_DEBUG="Cancelar depuración remota";
ui_strings.S_BUTTON_COLOR_RESTORE_DEFAULTS="Recuperar predeterminados";
ui_strings.S_BUTTON_EDIT_CUSTOM_EVENT="Editar";
ui_strings.S_BUTTON_ENTER_ADVANCED_SEARCH="Más";
ui_strings.S_BUTTON_ENTER_ADVANCED_SEARCH_TOOLTIP="Mostrar búsqueda avanzada";
ui_strings.S_BUTTON_EXPAND_ALL_SECTIONS="Expandir todas las secciones";
ui_strings.S_BUTTON_LABEL_AT_ABORT="Detener al encontrar un mensaje abort";
ui_strings.S_BUTTON_LABEL_AT_ERROR="Mostrar errores sintácticos e interrumpir en excepciones";
ui_strings.S_BUTTON_LABEL_AT_EXCEPTION="Detener al encontrar una excepción";
ui_strings.S_BUTTON_LABEL_CLEAR_LOG="Limpiar los errores visibles";
ui_strings.S_BUTTON_LABEL_CLEAR_THREAD_LOG="Limpiar registro de hilos";
ui_strings.S_BUTTON_LABEL_CLOSE_WINDOW="Cierra ventana";
ui_strings.S_BUTTON_LABEL_CONTINUE="Continuar (%s)";
ui_strings.S_BUTTON_LABEL_EXPORT_DOM="Exportar el panel DOM actual";
ui_strings.S_BUTTON_LABEL_EXPORT_LOG="Exporta registro de hilos";
ui_strings.S_BUTTON_LABEL_GET_THE_WOHLE_TREE="Expandir el árbol DOM";
ui_strings.S_BUTTON_LABEL_HELP="Ayuda";
ui_strings.S_BUTTON_LABEL_HIDE_DEFAULT_PROPS_IN_GLOBAL_SCOPE="Mostrar propiedades predeterminadas en ámbito global";
ui_strings.S_BUTTON_LABEL_LOG_THREADS="Registrar hilos";
ui_strings.S_BUTTON_LABEL_RELOAD_HOST="Recargar la ventana elegida en el navegador";
ui_strings.S_BUTTON_LABEL_SELECT_WINDOW="Elija el contexto de depuración que desee depurar";
ui_strings.S_BUTTON_LABEL_SETTINGS="Configuración";
ui_strings.S_BUTTON_LABEL_STEP_INTO="Ir a (%s)";
ui_strings.S_BUTTON_LABEL_STEP_OUT="Salir de (%s)";
ui_strings.S_BUTTON_LABEL_STEP_OVER="Saltar (%s)";
ui_strings.S_BUTTON_LABEL_STOP_AT_THREAD="Detener al inicio de un script nuevo";
ui_strings.S_BUTTON_LEAVE_ADVANCED_SEARCH="Menos";
ui_strings.S_BUTTON_LEAVE_ADVANCED_SEARCH_TOOLTIP="Mostrar barra de búsquedas";
ui_strings.S_BUTTON_LOAD_PO_FILE="Cargar fichero PO";
ui_strings.S_BUTTON_OK="Aceptar";
ui_strings.S_BUTTON_REMOVE_ALL_BREAKPOINTS="Eliminar todas las interrupciones";
ui_strings.S_BUTTON_RESET_ALL_TO_DEFAULTS="Restaurar configuración predeterminada";
ui_strings.S_BUTTON_RESET_TO_DEFAULTS="Recuperar predeterminados";
ui_strings.S_BUTTON_SAVE="Guardar";
ui_strings.S_BUTTON_SEARCH_EVENT="Buscar un evento";
ui_strings.S_BUTTON_SEARCH_SHORTCUT="Buscar atajos de teclado";
ui_strings.S_BUTTON_SET_DEFAULT_VALUE="Recuperar predeterminados";
ui_strings.S_BUTTON_SHOW_REQUEST_HEADERS="Encabezados";
ui_strings.S_BUTTON_SHOW_REQUEST_RAW="Cruda";
ui_strings.S_BUTTON_SHOW_REQUEST_SUMMARY="Resumen";
ui_strings.S_BUTTON_SPOTLIGHT_RESET_DEFAULT_COLORS="Volver a colores predeterminados";
ui_strings.S_BUTTON_STORAGE_DELETE_ALL="Borrar todo";
ui_strings.S_BUTTON_STORE_COLOR="Guardar color";
ui_strings.S_BUTTON_TAKE_SCREENSHOT="Capturar la pantalla";
ui_strings.S_BUTTON_TEXT_APPLY="Aplicar";
ui_strings.S_BUTTON_TOGGLE_CONSOLE="Alternar consola";
ui_strings.S_BUTTON_TOGGLE_REMOTE_DEBUG="Configuración remota de depuración";
ui_strings.S_BUTTON_TOGGLE_SETTINGS="Configuración";
ui_strings.S_BUTTON_UPDATE_SCREESHOT="Actualizar captura";
ui_strings.S_CLEAR_COMMAND_LINE_LOG="Limpiar consola";
ui_strings.S_CLEAR_NETWORK_LOG="Limpiar registro de red";
ui_strings.S_CLOSE_COMMAND_LINE="Cerrar consola";
ui_strings.S_COLOR_NOTATION="Formato de color";
ui_strings.S_COLOR_PICKER_AVERAGE_COLOR_OF="Color promedio de";
ui_strings.S_COLUMN_LABEL_ERROR="Error";
ui_strings.S_COLUMN_LABEL_FILE="Archivo";
ui_strings.S_COLUMN_LABEL_LINE="Línea";
ui_strings.S_CONFIRM_LOAD_COMPATIBLE_VERSION="La versión del protocolo de Opera no conicide con la que está usando Opera Dragonfly.\n\n¿Intento cargar una versión compatible?";
ui_strings.S_CONSOLE_TRACE_LABEL="Pila de llamadas:";
ui_strings.S_COOKIE_MANAGER_IN_1_HOUR="En 1 hora";
ui_strings.S_COOKIE_MANAGER_IN_1_MINUTE="En 1 minuto";
ui_strings.S_COOKIE_MANAGER_IN_1_MONTH="En 1 mes";
ui_strings.S_COOKIE_MANAGER_IN_1_WEEK="En 1 semana";
ui_strings.S_COOKIE_MANAGER_IN_1_YEAR="En 1 año";
ui_strings.S_COOKIE_MANAGER_IN_X_DAYS="En %s días";
ui_strings.S_COOKIE_MANAGER_IN_X_HOURS="En %s horas";
ui_strings.S_COOKIE_MANAGER_IN_X_MINUTES="En %s minutos";
ui_strings.S_COOKIE_MANAGER_IN_X_MONTHS="En %s meses";
ui_strings.S_COOKIE_MANAGER_IN_X_WEEKS="En %s semanas";
ui_strings.S_COOKIE_MANAGER_IN_X_YEARS="En %s años";
ui_strings.S_COOKIE_MANAGER_SOONER_THEN_1_MINUTE="< 1 minuto";
ui_strings.S_COOKIE_MANAGER_TOMORROW="Mañana";
ui_strings.S_DISABLE_DECLARATION="Desactivar";
ui_strings.S_DRAGONFLY_INFO_MESSAGE="Mensaje informativo de Opera Dragonfly: \n";
ui_strings.S_ENABLE_DECLARATION="Activar";
ui_strings.S_ERROR_LOG_CSS_FILTER="Usar filtro CSS";
ui_strings.S_ERRORS_MAXIMUM_REACHED="Mostrando %(MAX)s de %(COUNT)s errores";
ui_strings.S_EXPAND_SHORTHANDS="Expandir abreviaturas";
ui_strings.S_GLOBAL_KEYBOARD_SHORTCUTS_SECTION_TITLE="Global";
ui_strings.S_GLOBAL_SCOPE_NAME="<ámbito global>";
ui_strings.S_HELP_COMMAND_LINE="Ayuda";
ui_strings.S_HTTP_EVENT_SEQUENCE_INFO_ABORTING_REQUEST="Petición anulada";
ui_strings.S_HTTP_EVENT_SEQUENCE_INFO_ABORT_RETRYING="La secuencia ha terminado, pruebe de nuevo";
ui_strings.S_HTTP_EVENT_SEQUENCE_INFO_CLOSING_RESPONSE_PHASE="Cerrando fase de respuesta";
ui_strings.S_HTTP_EVENT_SEQUENCE_INFO_PROCESSING="Procesando";
ui_strings.S_HTTP_EVENT_SEQUENCE_INFO_PROCESSING_RESPONSE="Procesando respuesta";
ui_strings.S_HTTP_EVENT_SEQUENCE_INFO_READING_LOCAL_DATA="Leyendo datos locales";
ui_strings.S_HTTP_EVENT_SEQUENCE_INFO_REDIRECTING="Redirigiendo";
ui_strings.S_HTTP_EVENT_SEQUENCE_INFO_SCHEDULING="Programando petición";
ui_strings.S_HTTP_EVENT_SEQUENCE_READING_RESPONSE_BODY="Leyendo cuerpo de respuesta";
ui_strings.S_HTTP_EVENT_SEQUENCE_READING_RESPONSE_HEADER="Leyendo cabecera de respuesta";
ui_strings.S_HTTP_EVENT_SEQUENCE_WAITING_FOR_RESPONSE="Esperando respuesta";
ui_strings.S_HTTP_EVENT_SEQUENCE_WRITING_REQUEST_BODY="Escribiendo cuerpo de petición";
ui_strings.S_HTTP_EVENT_SEQUENCE_WRITING_REQUEST_HEADER="Escribiendo cabecera de petición";
ui_strings.S_HTTP_INCOMPLETE_LOADING_GRAPH="Recargar para ver todas las peticiones de página";
ui_strings.S_HTTP_LABEL_DATA_VIEW="Visor de datos";
ui_strings.S_HTTP_LABEL_DURATION="Duración";
ui_strings.S_HTTP_LABEL_FILTER_ALL="Todos";
ui_strings.S_HTTP_LABEL_FILTER_IMAGES="Imágenes";
ui_strings.S_HTTP_LABEL_FILTER_MARKUP="Marcas";
ui_strings.S_HTTP_LABEL_FILTER_OTHER="Otros";
ui_strings.S_HTTP_LABEL_FILTER_SCRIPTS="Scripts";
ui_strings.S_HTTP_LABEL_FILTER_STYLESHEETS="Hojas de estilo";
ui_strings.S_HTTP_LABEL_FILTER_XHR="XHR";
ui_strings.S_HTTP_LABEL_GRAPH="Gráfico";
ui_strings.S_HTTP_LABEL_GRAPH_VIEW="Vista gráfica";
ui_strings.S_HTTP_LABEL_HOST="Servidor";
ui_strings.S_HTTP_LABEL_METHOD="Método";
ui_strings.S_HTTP_LABEL_PATH="Ruta";
ui_strings.S_HTTP_LABEL_QUERY_ARGS="Argumentos de petición";
ui_strings.S_HTTP_LABEL_RESPONSE="Respuesta";
ui_strings.S_HTTP_LABEL_RESPONSECODE="Estado";
ui_strings.S_HTTP_LABEL_STARTED="Iniciado";
ui_strings.S_HTTP_LABEL_URL="URL";
ui_strings.S_HTTP_LABEL_WAITING="Esperando";
ui_strings.S_HTTP_NOT_REQUESTED="En caché";
ui_strings.S_HTTP_REQUESTED_HEADLINE="Solicitado a las %s";
ui_strings.S_HTTP_SERVED_OVER_FILE="Local";
ui_strings.S_HTTP_TOOLTIP_DURATION="Tiempo transcurrido entre el inicio y el fin de esta URL";
ui_strings.S_HTTP_TOOLTIP_FILTER_ALL="Ver todas las peticiones";
ui_strings.S_HTTP_TOOLTIP_FILTER_IMAGES="Ver sólo imágenes";
ui_strings.S_HTTP_TOOLTIP_FILTER_MARKUP="Ver sólo marcas";
ui_strings.S_HTTP_TOOLTIP_FILTER_OTHER="Ver peticiones de otro tipo";
ui_strings.S_HTTP_TOOLTIP_FILTER_SCRIPTS="Ver sólo scripts";
ui_strings.S_HTTP_TOOLTIP_FILTER_STYLESHEETS="Ver sólo hojas de estilo";
ui_strings.S_HTTP_TOOLTIP_FILTER_XHR="Ver sólo XMLHttpRequests";
ui_strings.S_HTTP_TOOLTIP_GRAPH="Gráfico de la secuencia de carga";
ui_strings.S_HTTP_TOOLTIP_MIME="Tipo Mime";
ui_strings.S_HTTP_TOOLTIP_PROTOCOL="Protocolo";
ui_strings.S_HTTP_TOOLTIP_RESPONSECODE="Código de estado HTTP";
ui_strings.S_HTTP_TOOLTIP_SIZE="Longitud del contenido de la respuesta, en bytes";
ui_strings.S_HTTP_TOOLTIP_SIZE_PRETTYPRINTED="Longitud del contenido de la respuesta";
ui_strings.S_HTTP_TOOLTIP_STARTED="Hora de inicio, relativa al documento principal";
ui_strings.S_HTTP_TOOLTIP_WAITING="Tiempo usado al pedir este recurso";
ui_strings.S_HTTP_UNREFERENCED="No referenciado";
ui_strings.S_INFO_DOCUMENT_HAS_NO_STYLESHEETS="Este documento no tiene hoja de estilos";
ui_strings.S_INFO_DOCUMNENT_LOADING="Actualizando Opera Dragonfly…";
ui_strings.S_INFO_ERROR_LISTENING="Hubo un error. Compruebe que el puerto %s no esté en uso.";
ui_strings.S_INFO_INVALID_REGEXP="Expresión regular no válida";
ui_strings.S_INFO_INVERT_ELEMENT_HIGHLIGHT="El resalte de color del elemento se puede invertir con el atajo \"%s\" ";
ui_strings.S_INFO_IS_SEARCHING="Buscando…";
ui_strings.S_INFO_NETWORK_UPDATES_PAUSED="Detenida la actualización de la bitácora de red.";
ui_strings.S_INFO_NO_COMPATIBLE_VERSION="No hay una versión compatible de Opera Dragonfly.";
ui_strings.S_INFO_NO_JAVASCRIPT_IN_CONTEXT="No hay entorno JavaScript en la ventana activa";
ui_strings.S_INFO_NO_VALID_PORT_NUMBER="Elija un número de puerto entre %s y %s";
ui_strings.S_INFO_REGEXP_MATCHES_EMPTY_STRING="La RegExp concuerda con una cadena vacía. No se ha efectuado la búsqueda.";
ui_strings.S_INFO_RELOAD_FOR_SCRIPT="Clic en el botón recargar para obtener los scripts para el contexto de depuración elegido";
ui_strings.S_INFO_REQUEST_FAILED="La solicitud ha fallado.";
ui_strings.S_INFO_RUNTIME_HAS_NO_SCRIPTS="Este documento no tiene scripts";
ui_strings.S_INFO_STORAGE_TYPE_DOES_NOT_EXIST="%s no existe.";
ui_strings.S_INFO_STYLESHEET_HAS_NO_RULES="Esta hoja de estilos no tiene reglas";
ui_strings.S_INFO_TOO_MANY_SEARCH_RESULTS="Mostrando %(MAX)s de %(COUNT)s";
ui_strings.S_INFO_WAITING_FORHOST_CONNECTION="Esperando conexión al host en puerto %s.";
ui_strings.S_INFO_WINDOW_HAS_NO_RUNTIME="Esta ventana no tiene tiempo de ejecución";
ui_strings.S_INHERITED_FROM="Heredado de";
ui_strings.S_INPUT_DEFAULT_TEXT_FILTER="Filtro";
ui_strings.S_INPUT_DEFAULT_TEXT_SEARCH="Buscar";
ui_strings.S_KEYBOARD_SHORTCUTS_CONFIGURATION="Configuración";
ui_strings.S_LABEL_ADD_WATCH="Añadir seguimiento";
ui_strings.S_LABEL_CHANGE_UI_LANGUAGE_INFO="Cambiar %s a uno de estos";
ui_strings.S_LABEL_COLLAPSED_INSPECTED_PROTOTYPES="Objetos prototipo agrupados por defecto (una lista de prototipos, p. e.  Object, Array, etc. * los agrupará a todos):";
ui_strings.S_LABEL_COLOR_HUE="Tono";
ui_strings.S_LABEL_COLOR_LUMINOSITY="Luminosidad";
ui_strings.S_LABEL_COLOR_OPACITY="Opacidad";
ui_strings.S_LABEL_COLOR_PICKER_SAMPLE_SIZE="Tamaño de muestra";
ui_strings.S_LABEL_COLOR_PICKER_ZOOM="Ampliar";
ui_strings.S_LABEL_COLOR_SATURATION="Saturación";
ui_strings.S_LABEL_COOKIE_MANAGER_ADD_COOKIE="Añadir cookie";
ui_strings.S_LABEL_COOKIE_MANAGER_COOKIE_DOMAIN="Dominio";
ui_strings.S_LABEL_COOKIE_MANAGER_COOKIE_EXPIRED="(caducado)";
ui_strings.S_LABEL_COOKIE_MANAGER_COOKIE_EXPIRES="Caduca";
ui_strings.S_LABEL_COOKIE_MANAGER_COOKIE_EXPIRES_ON_SESSION_CLOSE="Al terminar la sesión, p. e. la pestaña se cierra";
ui_strings.S_LABEL_COOKIE_MANAGER_COOKIE_EXPIRES_ON_SESSION_CLOSE_SHORT="Sesión";
ui_strings.S_LABEL_COOKIE_MANAGER_COOKIE_NAME="Nombre";
ui_strings.S_LABEL_COOKIE_MANAGER_COOKIE_PATH="Ruta";
ui_strings.S_LABEL_COOKIE_MANAGER_COOKIE_VALUE="Valor";
ui_strings.S_LABEL_COOKIE_MANAGER_EDIT_COOKIE="Editar cookie";
ui_strings.S_LABEL_COOKIE_MANAGER_GROUPER_RUNTIME="tiempo de ejecución";
ui_strings.S_LABEL_COOKIE_MANAGER_HTTP_ONLY="HTTPOnly";
ui_strings.S_LABEL_COOKIE_MANAGER_REMOVE_COOKIE="Borrar cookie";
ui_strings.S_LABEL_COOKIE_MANAGER_REMOVE_COOKIES="Borrar cookies";
ui_strings.S_LABEL_COOKIE_MANAGER_REMOVE_COOKIES_OF="Borrar cookies de %s";
ui_strings.S_LABEL_COOKIE_MANAGER_SECURE_CONNECTIONS_ONLY="Seguro";
ui_strings.S_LABEL_DEFAULT_SELECTION="Predeterminado";
ui_strings.S_LABEL_DELETE_ALL_WATCHES="Borrar todos los seguimientos";
ui_strings.S_LABEL_DELETE_WATCH="Borrar seguimiento";
ui_strings.S_LABEL_DIALOG_DONT_SHOW_AGAIN="No mostrar otra vez";
ui_strings.S_LABEL_EDIT_WATCH="Editar seguimiento";
ui_strings.S_LABEL_FONT_SELECTION_FACE="Tipografía";
ui_strings.S_LABEL_FONT_SELECTION_LINE_HEIGHT="Interlineado";
ui_strings.S_LABEL_FONT_SELECTION_SIZE="Tamaño de letra";
ui_strings.S_LABEL_KEYBOARDCONFIG_FOR_VIEW="Atajos de teclado %s";
ui_strings.S_LABEL_KEYBOARDCONFIG_INVALID_SHORTCUT="Atajo de teclado no válido";
ui_strings.S_LABEL_KEYBOARDCONFIG_MODE_DEFAULT="Predeterminado";
ui_strings.S_LABEL_KEYBOARDCONFIG_MODE_EDIT="Editar";
ui_strings.S_LABEL_KEYBOARDCONFIG_MODE_EDIT_ATTR_AND_TEXT="Editar atributos y texto";
ui_strings.S_LABEL_KEYBOARDCONFIG_MODE_EDIT_MARKUP="Editar marca";
ui_strings.S_LABEL_MAX_SEARCH_HITS="Número máximo de resultados por búsqueda";
ui_strings.S_LABEL_MOVE_HIGHLIGHT_DOWN="Buscar siguiente";
ui_strings.S_LABEL_MOVE_HIGHLIGHT_UP="Buscar anterior";
ui_strings.S_LABEL_NETWORK_POST_DATA_NAME="Nombre";
ui_strings.S_LABEL_NETWORK_POST_DATA_VALUE="Valor";
ui_strings.S_LABEL_PORT="Puerto";
ui_strings.S_LABEL_REPL_BACKLOG_LENGTH="Nº de líneas de historial a guardar ";
ui_strings.S_LABEL_REPL_MODE_AUTOCOMPLETE="Autocompletar";
ui_strings.S_LABEL_REPL_MODE_DEFAULT="Predeterminado";
ui_strings.S_LABEL_REPL_MODE_MULTILINE="Edición de línea múltiple";
ui_strings.S_LABEL_REPL_MODE_SINGLELINE="Edición de línea única";
ui_strings.S_LABEL_SCOPE_CHAIN="Cadena de ámbito";
ui_strings.S_LABEL_SEARCH_ALL_FILES="Todos los ficheros";
ui_strings.S_LABEL_SEARCH_FLAG_IGNORE_CASE="Ignorar Mayús/min";
ui_strings.S_LABEL_SEARCH_INJECTED_SCRIPTS="Inyectado";
ui_strings.S_LABEL_SEARCH_INJECTED_SCRIPTS_TOOLTIP="Buscar en todos los scripts inyectados, incluyendo Browser JS, Extension JS y User JS";
ui_strings.S_LABEL_SEARCH_TYPE_CSS="Selector";
ui_strings.S_LABEL_SEARCH_TYPE_REGEXP="RegExp";
ui_strings.S_LABEL_SEARCH_TYPE_TEXT="Texto";
ui_strings.S_LABEL_SEARCH_TYPE_XPATH="XPath";
ui_strings.S_LABEL_SHOW_JS_TOOLTIP="Ver ayuda emergente de inspección";
ui_strings.S_LABEL_SPOTLIGHT_TITLE="Color de resalte";
ui_strings.S_LABEL_STORAGE_ADD="Añadir";
ui_strings.S_LABEL_STORAGE_ADD_STORAGE_TYPE="Añadir %s";
ui_strings.S_LABEL_STORAGE_DELETE="Eliminar";
ui_strings.S_LABEL_STORAGE_DOUBLE_CLICK_TO_EDIT="Hacer doble clic para editar";
ui_strings.S_LABEL_STORAGE_KEY="Clave";
ui_strings.S_LABEL_STORAGE_UPDATE="Actualizar";
ui_strings.S_LABEL_TAB_SIZE="Tamaño de pestaña";
ui_strings.S_LABEL_UTIL_AREA="Área";
ui_strings.S_LABEL_UTIL_SCALE="Escala";
ui_strings.S_MENU_DEBUG_CONTEXT="Elegir contexto de depuración";
ui_strings.S_MENU_RELOAD_DEBUG_CONTEXT="Recargar contexto de depuración";
ui_strings.S_MENU_RELOAD_DEBUG_CONTEXT_SHORT="Recargar";
ui_strings.S_MENU_SELECT_ACTIVE_WINDOW="Elegir ventana activa";
ui_strings.S_NETWORK_BODY_NOT_AVAILABLE="El cuerpo de la petición no está disponible. Active el rastreo de recursos y recargue la página para verlo.";
ui_strings.S_NETWORK_CACHING_SETTING_DEFAULT_LABEL="Comportamiento estándar del caché de Opera";
ui_strings.S_NETWORK_CACHING_SETTING_DESC="Este ajuste controla cómo funciona el caché al ejecutar Opera Dragonfly. Si se desactiva, Opera siempre recarga la página.";
ui_strings.S_NETWORK_CACHING_SETTING_DISABLED_LABEL="Desactivar caché";
ui_strings.S_NETWORK_CACHING_SETTING_TITLE="Comportamiento del caché";
ui_strings.S_NETWORK_CANT_DISPLAY_TYPE="No se puede ver el contenido del tipo %s";
ui_strings.S_NETWORK_CONTENT_TRACKING_SETTING_TRACK_LABEL="Rastrear contenido (afecta velocidad/memoria)";
ui_strings.S_NETWORK_ENABLE_CONTENT_TRACKING_FOR_REQUEST="Active seguimiento de contenidos en el panel \"opciones de red\" para ver el cuerpo de la petición";
ui_strings.S_NETWORK_HEADER_EXAMPLE_VAL_NAME="Nombre de encabezado";
ui_strings.S_NETWORK_HEADER_EXAMPLE_VAL_VALUE="Valor de cabecera";
ui_strings.S_NETWORK_HEADER_OVERRIDES_DESC="Las cabeceras en la caja de anulaciones se usarán para toda petición en el navegador en depuración. Sustituyen a las cabeceras normales.";
ui_strings.S_NETWORK_HEADER_OVERRIDES_LABEL="Activa anulaciones globales de cabeceras ";
ui_strings.S_NETWORK_HEADER_OVERRIDES_PRESET_NONE="Ninguno";
ui_strings.S_NETWORK_HEADER_OVERRIDES_PRESETS_LABEL="Programaciones";
ui_strings.S_NETWORK_HEADER_OVERRIDES_PRESETS_SAVE="Guardar";
ui_strings.S_NETWORK_HEADER_OVERRIDES_TITLE="Saltar cabeceras globales";
ui_strings.S_NETWORK_MULTIPART_REQUEST_TITLE="Petición - multiparte";
ui_strings.S_NETWORK_N_BYTE_BODY="Cuerpo de petición de %s bytes";
ui_strings.S_NETWORK_REQUEST="Petición";
ui_strings.S_NETWORK_REQUEST_DETAIL_BODY_DESC="Cuerpo de respuesta no rastreado. Para disponer siempre de cuerpos de respuesta, active la opción \"Rastrear contenido\" en opciones. Para obtener sólo este cuerpo, haga clic en el botón.";
ui_strings.S_NETWORK_REQUEST_DETAIL_BODY_UNFINISHED="No se dispone del cuerpo de respuesta hasta que la petición termine";
ui_strings.S_NETWORK_REQUEST_DETAIL_NO_RESPONSE_BODY="El cuerpo de la respuesta no está disponible. Active \"Rastrear contenido\" en opciones y recargue la página para verlo.";
ui_strings.S_NETWORK_REQUEST_DETAIL_REQUEST_TITLE="Petición";
ui_strings.S_NETWORK_REQUEST_DETAIL_RESPONSE_TITLE="Respuesta";
ui_strings.S_NETWORK_REQUEST_DETAIL_UNDISPLAYABLE_BODY_LABEL="Imposible mostrar datos del tipo %s";
ui_strings.S_NETWORK_REQUEST_NO_HEADERS_LABEL="Sin cabeceras";
ui_strings.S_NETWORK_REQUESTS="Peticiones";
ui_strings.S_NETWORK_REQUESTS_INCOMPLETE_SETTING_LABEL="Ver notificación cuando no se vean todas las peticiones de red";
ui_strings.S_NETWORK_SERVED_FROM_CACHE="No ha habido petición. Los datos se obtuvieron del caché, sin acceder a la red";
ui_strings.S_NETWORK_UNKNOWN_MIME_TYPE="Se desconoce el tipo MIME de los datos pedidos";
ui_strings.S_NONE="Ninguno";
ui_strings.S_REMOTE_DEBUG_GUIDE_PRECONNECT_HEADER="Pasos para activar depuración remota:";
ui_strings.S_REMOTE_DEBUG_GUIDE_PRECONNECT_STEP_1="Indicar el número de puerto en el que conectar, o dejar el predeterminado";
ui_strings.S_REMOTE_DEBUG_GUIDE_PRECONNECT_STEP_2="Clic en \"Aplicar\"";
ui_strings.S_REMOTE_DEBUG_GUIDE_WAITING_HEADER="En el dispositivo remoto:";
ui_strings.S_REMOTE_DEBUG_GUIDE_WAITING_STEP_1="Escriba opera:debug en el campo de URL";
ui_strings.S_REMOTE_DEBUG_GUIDE_WAITING_STEP_2="Escriba la dirección IP de la máquina que ejecuta Opera Dragonfly";
ui_strings.S_REMOTE_DEBUG_GUIDE_WAITING_STEP_3="Escriba el nº de puerto %s";
ui_strings.S_REMOTE_DEBUG_GUIDE_WAITING_STEP_4="Clic para \"Conectar\"";
ui_strings.S_REMOTE_DEBUG_GUIDE_WAITING_STEP_5="Una vez conectado, vaya a la página que quiere depurar";
ui_strings.S_REPL_HELP_COMMAND_DESC="Ver lista de comandos disponibles";
ui_strings.S_REPL_JQUERY_COMMAND_DESC="Cargar jQuery en la pestaña activa";
ui_strings.S_REPL_WELCOME_TEXT="Use %(CLEAR_COMMAND)s para limpiar la consola.\nEscriba %(HELP_COMMAND)s si necesita más información";
ui_strings.S_RESOURCE_ALL_NOT_APPLICABLE="n/a";
ui_strings.S_RESOURCE_ALL_TABLE_COLUMN_HOST="Servidor";
ui_strings.S_RESOURCE_ALL_TABLE_COLUMN_MIME="Mime";
ui_strings.S_RESOURCE_ALL_TABLE_COLUMN_PATH="Ruta";
ui_strings.S_RESOURCE_ALL_TABLE_COLUMN_PPSIZE="Tamaño (impreso)";
ui_strings.S_RESOURCE_ALL_TABLE_COLUMN_PROTOCOL="Protocolo";
ui_strings.S_RESOURCE_ALL_TABLE_COLUMN_SIZE="Tamaño";
ui_strings.S_RESOURCE_ALL_TABLE_COLUMN_TYPE="Tipo";
ui_strings.S_RESOURCE_ALL_TABLE_GROUP_GROUPS="Grupos";
ui_strings.S_RESOURCE_ALL_TABLE_GROUP_HOSTS="Servidores";
ui_strings.S_RESOURCE_ALL_TABLE_NO_FILENAME="<sin nombre>";
ui_strings.S_RESOURCE_ALL_TABLE_NO_HOST="Sin servidor";
ui_strings.S_RESOURCE_ALL_TABLE_UNKNOWN_GROUP="Desconocido";
ui_strings.S_RESOURCE_CLICK_BUTTON_TO_FETCH_RESOURCES="Clic en el botón recargar para obtener los recursos de la ventana depurada";
ui_strings.S_SCOPE_GLOBAL="Global";
ui_strings.S_SCOPE_INNER="Ámbito %s";
ui_strings.S_SCRIPT_SELECT_SECTION_BROWSER_AND_USER_JS="JS de navegador y usuario";
ui_strings.S_SCRIPT_SELECT_SECTION_INLINE_AND_EVALS="Scripts inline, eval, timeout y event-handler";
ui_strings.S_SEARCH_INPUT_TOOLTIP="buscar texto";
ui_strings.S_SETTINGS_HEADER_ABOUT="Acerca de";
ui_strings.S_SETTINGS_HEADER_CONSOLE="Registro de errores";
ui_strings.S_SETTINGS_HEADER_DOCUMENT="Documentos";
ui_strings.S_SETTINGS_HEADER_GENERAL="General";
ui_strings.S_SETTINGS_HEADER_KEYBOARD_SHORTCUTS="Atajos de teclado";
ui_strings.S_SETTINGS_HEADER_NETWORK="Red";
ui_strings.S_SETTINGS_HEADER_SCRIPT="Scripts";
ui_strings.S_STYLE_ORIGIN_LOCAL="Hojas de estilo de usuario";
ui_strings.S_STYLE_ORIGIN_SVG="atributos de presentación";
ui_strings.S_STYLE_ORIGIN_USER_AGENT="hoja de estilo de agente de usuario";
ui_strings.S_SWITCH_ATTACH_WINDOW="Acoplar a la ventana principal";
ui_strings.S_SWITCH_AUTO_SCROLL_REQUEST_LIST="Desplazar automáticamente bitácora de peticiones";
ui_strings.S_SWITCH_DETACH_WINDOW="Desacoplar a ventana separada";
ui_strings.S_SWITCH_EXPAND_ALL="Expandir todo";
ui_strings.S_SWITCH_EXPAND_OBJECTS_INLINE="En consola, despliega los objetos en línea";
ui_strings.S_SWITCH_FIND_ELEMENT_BY_CLICKING="Elegir elemento en página para inspeccionarlo";
ui_strings.S_SWITCH_FRIENDLY_PRINT="Habilitar impresión inteligente para objetos Element en la consola";
ui_strings.S_SWITCH_HIDE_EMPTY_STRINGS="Ver cadenas vacías y valores cero";
ui_strings.S_SWITCH_HIGHLIGHT_SELECTED_OR_HOVERED_ELEMENT="Resaltar elemento seleccionado ";
ui_strings.S_SWITCH_IS_ELEMENT_SENSITIVE="Muestra en el panel DOM los objetos Element cuando se eligen en consola";
ui_strings.S_SWITCH_LOCK_SELECTED_ELEMENTS="Mantener resaltados los elementos";
ui_strings.S_SWITCH_RELOAD_SCRIPTS_AUTOMATICALLY="Recargar automáticamente nuevo contexto de depuración";
ui_strings.S_SWITCH_REMOTE_DEBUG="Depuración remota";
ui_strings.S_SWITCH_SCROLL_INTO_VIEW_ON_FIRST_SPOTLIGHT="Desplazar hasta ser visible al resaltar";
ui_strings.S_SWITCH_SHOW_COMMENT_NODES="Ver nodos comentario";
ui_strings.S_SWITCH_SHOW_DOM_INTREE_VIEW="Representar el DOM con árbol de nodos";
ui_strings.S_SWITCH_SHOW_ECMA_ERRORS_IN_COMMAND_LINE="Ver errores de Javascript en la consola";
ui_strings.S_SWITCH_SHOW_FEFAULT_NULLS_AND_EMPTY_STRINGS="Ver valores predeterminados si son literales nulos o vacíos";
ui_strings.S_SWITCH_SHOW_ID_AND_CLASSES_IN_BREAD_CRUMB="Ver id y clases en la línea de navegación";
ui_strings.S_SWITCH_SHOW_INITIAL_VALUES="Ver valores iniciales";
ui_strings.S_SWITCH_SHOW_NON_ENUMERABLES="Ver propiedades no enumerables";
ui_strings.S_SWITCH_SHOW_ONLY_NORMAL_AND_GADGETS_TYPE_WINDOWS="Oculta elementos específicos del navegador, como correo o ventanas de fuentes web";
ui_strings.S_SWITCH_SHOW_PROTOTYPES="Mostrar prototipos";
ui_strings.S_SWITCH_SHOW_PSEUDO_ELEMENTS="Ver seudo elementos";
ui_strings.S_SWITCH_SHOW_SIBLINGS_IN_BREAD_CRUMB="Ver hijos en la línea de navegación";
ui_strings.S_SWITCH_SHOW_TAB_ALL="Todos";
ui_strings.S_SWITCH_SHOW_TAB_BITTORRENT="BitTorrent";
ui_strings.S_SWITCH_SHOW_TAB_CSS="CSS";
ui_strings.S_SWITCH_SHOW_TAB_HTML="HTML";
ui_strings.S_SWITCH_SHOW_TAB_JAVA="Java";
ui_strings.S_SWITCH_SHOW_TAB_M2="Correo";
ui_strings.S_SWITCH_SHOW_TAB_NETWORK="Redes";
ui_strings.S_SWITCH_SHOW_TAB_SCRIPT="JavaScript";
ui_strings.S_SWITCH_SHOW_TAB_SVG="SVG";
ui_strings.S_SWITCH_SHOW_TAB_VOICE="Voz";
ui_strings.S_SWITCH_SHOW_TAB_WIDGET="Widgets";
ui_strings.S_SWITCH_SHOW_TAB_XML="XML";
ui_strings.S_SWITCH_SHOW_TAB_XSLT="XSLT";
ui_strings.S_SWITCH_SHOW_VIEWS_MENU="Mostrar menú Vistas";
ui_strings.S_SWITCH_SHOW_WHITE_SPACE_NODES="Ver nodos de espacio en blanco";
ui_strings.S_SWITCH_TAKE_SCREENSHOT_AUTOMATICALLY="Hacer una captura automáticamente al abrir las utilidades";
ui_strings.S_SWITCH_TRACK_USAGE="Seguimiento de uso. Envía una ID de usuario aleatoria para seguir el número de usos";
ui_strings.S_SWITCH_UNPACK_LIST_ALIKES="En consola, despliega los objetos que actúan como listas";
ui_strings.S_SWITCH_UPDATE_DOM_ON_NODE_REMOVE="Actualizar DOM cuando se elimine un nodo";
ui_strings.S_SWITCH_UPDATE_GLOBAL_SCOPE="Actualizar automáticamente ámbito global";
ui_strings.S_SWITCH_USE_LOWER_CASE_TAG_NAMES="Usar etiquetas en minúsculas para text/html";
ui_strings.S_TEXT_CALL_STACK_FRAME_LINE="%(FUNCTION_NAME)s: %(SCRIPT_ID)s:%(LINE_NUMBER)s";
ui_strings.S_TEXT_ECMA_SCRIPT_SCRIPT_ID="Id del script";
ui_strings.S_TEXT_ECMA_SCRIPT_TYPE_INLINE="En línea";
ui_strings.S_TEXT_ECMA_SCRIPT_TYPE_LINKED="Enlazado";
ui_strings.S_TEXT_ECMA_SCRIPT_TYPE_UNKNOWN="Desconocido";
ui_strings.S_TEXT_ENVIRONMENT_DRAGONFLY_VERSION="Versión de Opera Dragonfly";
ui_strings.S_TEXT_ENVIRONMENT_OPERATING_SYSTEM="Sistema operativo";
ui_strings.S_TEXT_ENVIRONMENT_PLATFORM="Plataforma";
ui_strings.S_TEXT_ENVIRONMENT_PROTOCOL_VERSION="Versión de protocolo";
ui_strings.S_TEXT_ENVIRONMENT_REVISION_NUMBER="Número de revisión";
ui_strings.S_TEXT_ENVIRONMENT_USER_AGENT="Agente de usuario";
ui_strings.S_TEXT_STATUS_SEARCH="Coincidencias con %(SEARCH_TERM)s: Coinciden %(SEARCH_COUNT_INDEX)s de %(SEARCH_COUNT_TOTAL)s";
ui_strings.S_TEXT_STATUS_SEARCH_NO_MATCH="Sin coincidencias para \"%(SEARCH_TERM)s\"";
ui_strings.S_TOGGLE_DOM_MODEBAR="Mostrar la línea de navegación";
ui_strings.S_TOGGLE_DOM_MODEBAR_HEADER="Línea de navegación";
ui_strings.S_TOGGLE_PAUSED_UPDATING_NETWORK_VIEW="Pausar actualización de la actividad de red";
ui_strings.D_REDO_SEARCH="El documento buscado ya no existe.\n¿Repetir la búsqueda en el actual?";
ui_strings.D_RELOAD_SCRIPTS="No se han cargado todos los scripts. ¿Desea recargar la página?";
ui_strings.M_CONTEXTMENU_ADD_ATTRIBUTE="Editar atributos";
ui_strings.M_CONTEXTMENU_ADD_BREAKPOINT="Añadir interrupcion";
ui_strings.M_CONTEXTMENU_ADD_COLOR="Añadir color";
ui_strings.M_CONTEXTMENU_ADD_CONDITION="Añadir condición";
ui_strings.M_CONTEXTMENU_ADD_DECLARATION="Añadir declaración";
ui_strings.M_CONTEXTMENU_ADD_WATCH="Seguir \"%s\"";
ui_strings.M_CONTEXTMENU_COLLAPSE_SUBTREE="Plegar subárbol";
ui_strings.M_CONTEXTMENU_DELETE="Eliminar";
ui_strings.M_CONTEXTMENU_DELETE_ALL="Borrar todo";
ui_strings.M_CONTEXTMENU_DELETE_ALL_BREAKPOINTS="Eliminar todas las interrupciones";
ui_strings.M_CONTEXTMENU_DELETE_BREAKPOINT="Eliminar interrupción";
ui_strings.M_CONTEXTMENU_DISABLE_BREAKPOINT="Desactivar interrupción";
ui_strings.M_CONTEXTMENU_DELETE_COLOR="Borrar color";
ui_strings.M_CONTEXTMENU_DELETE_CONDITION="Eliminar condición";
ui_strings.M_CONTEXTMENU_DISABLE_ALL="Desactivar todo";
ui_strings.M_CONTEXTMENU_DISABLE_ALL_BREAKPOINTS="Desactivar todas las interrupciones";
ui_strings.M_CONTEXTMENU_DISABLE_DECLARATIONS="Desactivar todas las declaraciones";
ui_strings.M_CONTEXTMENU_EDIT_ATTRIBUTE="Editar atributo";
ui_strings.M_CONTEXTMENU_EDIT_ATTRIBUTE_VALUE="Editar valor de atributo";
ui_strings.M_CONTEXTMENU_EDIT_COLOR="Editar color";
ui_strings.M_CONTEXTMENU_EDIT_CONDITION="Editar condición";
ui_strings.M_CONTEXTMENU_EDIT_DECLARATION="Editar declaración";
ui_strings.M_CONTEXTMENU_EDIT_MARKUP="Editar marca";
ui_strings.M_CONTEXTMENU_EDIT_TEXT="Editar texto";
ui_strings.M_CONTEXTMENU_ENABLE_BREAKPOINT="Activar interrupción";
ui_strings.M_CONTEXTMENU_EXPAND_SUBTREE="Desplegar subárbol";
ui_strings.M_CONTEXTMENU_OPEN_COLOR_PICKER="Abrir selector de color";
ui_strings.M_CONTEXTMENU_REMOVE_DECLARATION="Borrar declaración";
ui_strings.M_CONTEXTMENU_REMOVE_NODE="Borrar nodo";
ui_strings.M_CONTEXTMENU_SHOW_RESOURCE="Ver recurso";
ui_strings.M_CONTEXTMENU_SPEC_LINK="Especificacción para \"%s\"";
ui_strings.M_CONTEXTMENU_STORAGE_ADD="Añadir elemento";
ui_strings.M_CONTEXTMENU_STORAGE_DELETE="Borrar elemento";
ui_strings.M_CONTEXTMENU_STORAGE_DELETE_ALL_FROM="Borrar todo en %s";
ui_strings.M_CONTEXTMENU_STORAGE_DELETE_PLURAL="Borrar elementos";
ui_strings.M_CONTEXTMENU_STORAGE_EDIT="Editar elemento";
ui_strings.M_LABEL_CLEAR_ALL_ERRORS="Limpiar todos los errores";
ui_strings.M_LABEL_UI_LANGUAGE="Idioma de la interfaz de usuario";
ui_strings.M_NETWORK_CRAFTER_REQUEST_BODY="Cuerpo de petición";
ui_strings.M_NETWORK_CRAFTER_RESPONSE_BODY="Respuesta";
ui_strings.M_NETWORK_CRAFTER_SEND="Enviar petición";
ui_strings.M_NETWORK_REQUEST_DETAIL_DURATION="Duración";
ui_strings.M_NETWORK_REQUEST_DETAIL_GET_RESPONSE_BODY_LABEL="Obtener cuerpo de respuesta";
ui_strings.M_NETWORK_REQUEST_DETAIL_STATUS="Estado";
ui_strings.M_SETTING_LABEL_GENERAL="General";
ui_strings.M_SORTABLE_TABLE_CONTEXT_GROUP_BY="Agrupar por \"%s\"";
ui_strings.M_SORTABLE_TABLE_CONTEXT_NO_GROUPING="Sin agrupar";
ui_strings.M_SORTABLE_TABLE_CONTEXT_RESET_COLUMNS="Rehacer columnas";
ui_strings.M_SORTABLE_TABLE_CONTEXT_RESET_SORT="Rehacer orden";
ui_strings.M_VIEW_LABEL_ALL_RESOURCES="Todos los recursos";
ui_strings.M_VIEW_LABEL_BREAKPOINTS="Interrupciones";
ui_strings.M_VIEW_LABEL_CALLSTACK="Pila de llamadas";
ui_strings.M_VIEW_LABEL_COLOR_MAGNIFIER_AND_PICKER="Ampliador de píxeles y selector de color";
ui_strings.M_VIEW_LABEL_COLOR_PALETTE="Paleta de colores";
ui_strings.M_VIEW_LABEL_COLOR_PALETTE_SHORT="Paleta";
ui_strings.M_VIEW_LABEL_COLOR_PICKER="Selector de color";
ui_strings.M_VIEW_LABEL_COLOR_SELECT="Elegir color";
ui_strings.M_VIEW_LABEL_COMMAND_LINE="Consola";
ui_strings.M_VIEW_LABEL_COMPOSITE_DOM="Documentos";
ui_strings.M_VIEW_LABEL_COMPOSITE_ERROR_CONSOLE="Errores";
ui_strings.M_VIEW_LABEL_COMPOSITE_EXPORTS="Exportar";
ui_strings.M_VIEW_LABEL_COMPOSITE_SCRIPTS="Scripts";
ui_strings.M_VIEW_LABEL_COMPUTED_STYLE="Estilo calculado";
ui_strings.M_VIEW_LABEL_CONSOLE="Paneles de error";
ui_strings.M_VIEW_LABEL_COOKIES="Cookies";
ui_strings.M_VIEW_LABEL_DOM="Panel DOM";
ui_strings.M_VIEW_LABEL_DOM_ATTR="Propiedades";
ui_strings.M_VIEW_LABEL_ENVIRONMENT="Entorno";
ui_strings.M_VIEW_LABEL_ERROR_ALL="Todos";
ui_strings.M_VIEW_LABEL_ERROR_BITTORRENT="BitTorrent";
ui_strings.M_VIEW_LABEL_ERROR_CSS="CSS";
ui_strings.M_VIEW_LABEL_ERROR_HTML="HTML";
ui_strings.M_VIEW_LABEL_ERROR_JAVA="Java";
ui_strings.M_VIEW_LABEL_ERROR_LOCATION_TITLE="Línea %(LINE)s en %(URI)s";
ui_strings.M_VIEW_LABEL_ERROR_M2="Correo";
ui_strings.M_VIEW_LABEL_ERROR_NETWORK="Red";
ui_strings.M_VIEW_LABEL_ERROR_OTHER="Otros";
ui_strings.M_VIEW_LABEL_ERROR_SCRIPT="JavaScript";
ui_strings.M_VIEW_LABEL_ERROR_STORAGE="Almacenamiento";
ui_strings.M_VIEW_LABEL_ERROR_SVG="SVG";
ui_strings.M_VIEW_LABEL_ERROR_WIDGET="Widgets";
ui_strings.M_VIEW_LABEL_ERROR_XML="XML";
ui_strings.M_VIEW_LABEL_ERROR_XSLT="XSLT";
ui_strings.M_VIEW_LABEL_EVENT_BREAKPOINTS="Interrupciones de evento";
ui_strings.M_VIEW_LABEL_EXPORT="Exportar";
ui_strings.M_VIEW_LABEL_FRAME_INSPECTION="Inspección";
ui_strings.M_VIEW_LABEL_GO_TO_LINE="Ir a línea";
ui_strings.M_VIEW_LABEL_LAYOUT="Diseño";
ui_strings.M_VIEW_LABEL_LOCAL_STORAGE="Almacenaje local";
ui_strings.M_VIEW_LABEL_MONOSPACE_FONT="Tipografía monoespacio";
ui_strings.M_VIEW_LABEL_NETWORK="Red";
ui_strings.M_VIEW_LABEL_NETWORK_LOG="Registro de la red";
ui_strings.M_VIEW_LABEL_NETWORK_OPTIONS="Opciones de red";
ui_strings.M_VIEW_LABEL_NEW_STYLE="Estilo nuevo";
ui_strings.M_VIEW_LABEL_NO_BREAKPOINT="Sin interrupciones";
ui_strings.M_VIEW_LABEL_NO_INSPECTION="Sin inspección";
ui_strings.M_VIEW_LABEL_NOT_STOPPED="No detenido";
ui_strings.M_VIEW_LABEL_NO_WATCHES="Sin seguimientos";
ui_strings.M_VIEW_LABEL_RAW_REQUEST_INFO="Petición sin procesar";
ui_strings.M_VIEW_LABEL_RAW_RESPONSE_INFO="Respuesta sin procesar";
ui_strings.M_VIEW_LABEL_REQUEST_CRAFTER="Hacer petición";
ui_strings.M_VIEW_LABEL_REQUEST_HEADERS="Cabeceras de petición";
ui_strings.M_VIEW_LABEL_REQUEST_LOG="Registro de peticiones";
ui_strings.M_VIEW_LABEL_REQUEST_SUMMARY="Resumen peticiones";
ui_strings.M_VIEW_LABEL_RESOURCES="Recursos";
ui_strings.M_VIEW_LABEL_RESPONSE_BODY="Cuerpo de respuesta";
ui_strings.M_VIEW_LABEL_RESPONSE_HEADERS="Cabecera de respuesta";
ui_strings.M_VIEW_LABEL_RUNTIME_STATE="Estado";
ui_strings.M_VIEW_LABEL_SCRIPTS="Scripts";
ui_strings.M_VIEW_LABEL_SEARCH="Buscar";
ui_strings.M_VIEW_LABEL_SESSION_STORAGE="Almacenaje de sesión";
ui_strings.M_VIEW_LABEL_SOURCE="Código fuente";
ui_strings.M_VIEW_LABEL_STORAGE="Almacenaje";
ui_strings.M_VIEW_LABEL_STORED_COLORS="Paleta de colores";
ui_strings.M_VIEW_LABEL_STYLES="Estilos";
ui_strings.M_VIEW_LABEL_STYLESHEET="Hoja de estilo";
ui_strings.M_VIEW_LABEL_STYLESHEETS="Hojas de estilo";
ui_strings.M_VIEW_LABEL_THREAD_LOG="Registro de hilos";
ui_strings.M_VIEW_LABEL_UTILITIES="Utilidades";
ui_strings.M_VIEW_LABEL_VIEWS="Vistas";
ui_strings.M_VIEW_LABEL_WATCHES="Seguimientos";
ui_strings.M_VIEW_LABEL_WIDGET_PREFERNCES="Opciones de widgets";
ui_strings.M_VIEW_SUB_LABEL_METRICS="Métricas";
ui_strings.M_VIEW_SUB_LABEL_OFFSET_VALUES="Valor de desplazamiento";
ui_strings.M_VIEW_SUB_LABEL_PARENT_OFFSETS="Desplazamiento de precursores";


text:
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
// Code generated by Microsoft (R) AutoRest Code Generator.

package com.azure.resourcemanager.synapse.generated;

import com.azure.core.util.Context;
import com.azure.resourcemanager.synapse.fluent.models.DataConnectionValidationInner;
import com.azure.resourcemanager.synapse.models.EventHubDataConnection;

/** Samples for KustoPoolDataConnections DataConnectionValidation. */
public final class KustoPoolDataConnectionsDataConnectionValidationSamples {
    /*
     * x-ms-original-file: specification/synapse/resource-manager/Microsoft.Synapse/preview/2021-06-01-preview/examples/KustoPoolDataConnectionValidation.json
     */
    /**
     * Sample code: KustoPoolDataConnectionValidation.
     *
     * @param manager Entry point to SynapseManager.
     */
    public static void kustoPoolDataConnectionValidation(com.azure.resourcemanager.synapse.SynapseManager manager) {
        manager
            .kustoPoolDataConnections()
            .dataConnectionValidation(
                "kustorptest",
                "kustorptest",
                "kustoclusterrptest4",
                "KustoDatabase8",
                new DataConnectionValidationInner()
                    .withDataConnectionName("DataConnections8")
                    .withProperties(new EventHubDataConnection()),
                Context.NONE);
    }
}


text:
@implementation Registration

@dynamic uid;
@dynamic date;
@dynamic signature;
@dynamic student;

@end


text:
	<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>

	<title>content</title>
	<link rel="stylesheet" href="../../../build/aui-skin-classic/css/aui-skin-classic-all-min.css" type="text/css" media="screen" />
	<link rel="stylesheet" href="common.css" type="text/css" media="screen" />

	Show short text - Show long text - Go to external domain

		Show short text (Quirks Mode) - Show long text (Quirks)

Hover over me to make the text longer dynamically

Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.


text:
<?php

define('MAX_LOOPS',5);

function withRefValue($elements, $transform) {
	echo "\n---( Array with $elements element(s): )---\n";
	//Build array:
	for ($i=0; $i<$elements; $i++) {
		$a[] = "v.$i";
	}
	$counter=0;

	$ref = &$a;

	echo "--> State of referenced array before loop:\n";
	var_dump($a);

	echo "--> Do loop:\n";
	foreach ($a as $k=>$v) {
		echo "     iteration $counter:  \$k=$k; \$v=$v\n";
		eval($transform);
		$counter++;
		if ($counter>MAX_LOOPS) {
			echo "  ** Stuck in a loop! **\n";
			break;
		}
	}

	echo "--> State of array after loop:\n";
	var_dump($a);
}

echo "\nPopping elements off end of a referenced array";
$transform = 'array_pop($a);';
withRefValue(1, $transform);
withRefValue(2, $transform);
withRefValue(3, $transform);
withRefValue(4, $transform);

echo "\n\n\nShift elements off start of a referenced array";
$transform = 'array_shift($a);';
withRefValue(1, $transform);
withRefValue(2, $transform);
withRefValue(3, $transform);
withRefValue(4, $transform);

echo "\n\n\nRemove current element of a referenced array";
$transform = 'unset($a[$k]);';
withRefValue(1, $transform);
withRefValue(2, $transform);
withRefValue(3, $transform);
withRefValue(4, $transform);

echo "\n\n\nAdding elements to the end of a referenced array";
$transform = 'array_push($a, "new.$counter");';
withRefValue(1, $transform);
withRefValue(2, $transform);
withRefValue(3, $transform);
withRefValue(4, $transform);

echo "\n\n\nAdding elements to the start of a referenced array";
$transform = 'array_unshift($a, "new.$counter");';
withRefValue(1, $transform);
withRefValue(2, $transform);
withRefValue(3, $transform);
withRefValue(4, $transform);

?>