text:
#include "../../../include/libs-klipos.h"

//----------------------------- public functions

bool iapWriteBuffer(uint32_t flash_address, uint32_t bufferAddr, uint32_t count)
{
    uint32_t iapParameter[5];
    uint32_t iapResult[5];

    //todo disable irq
    //__disable_irq();

    iapParameter[0] = IAP_COPY_RAM_TO_FLASH;
    iapParameter[1] = flash_address;
    iapParameter[2] = (uint32_t)bufferAddr;
    iapParameter[3] = count;
    iapParameter[4] = IAP_CCLK;
    iapExecuteCommand(iapParameter,iapResult);

    //todo enable irq
    //__enable_irq();

    if(iapResult[0] != IAP_SUCCESS)
    {
        return false;
    }
    return true;
}

bool iapEraseSector(uint32_t start_sector,uint32_t end_sector)
{
    uint32_t iapParameter[5];
    uint32_t iapResult[5];

    iapParameter[0] = IAP_ERASE_SECTOR;
    iapParameter[1] = start_sector;
    iapParameter[2] = end_sector;
    iapParameter[3] = IAP_CCLK;
    iapExecuteCommand(iapParameter,iapResult);

    if(iapResult[0] != IAP_SUCCESS)
    {
        return false;
    }
    return true;
}

bool iapPrepareSector(uint32_t start_sector,uint32_t end_sector)
{
    uint32_t iapParameter[5];
    uint32_t iapResult[5];

    iapParameter[0] = IAP_PREPARE_SECTOR_FOR_WRITE;
    iapParameter[1] = start_sector;
    iapParameter[2] = end_sector;
    iapParameter[3] = IAP_CCLK;
    iapExecuteCommand(iapParameter,iapResult);

    if(iapResult[0] != IAP_SUCCESS)
    {
        return false;
    }
    return true;
}


text:
package rayo.ui.views.chains;

import static javax.swing.JOptionPane.ERROR_MESSAGE;
import static javax.swing.JOptionPane.showMessageDialog;
import static rayo.ui.widgets.WidgetUtils.getCodeFont;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Desktop;
import java.awt.Font;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.List;

import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.table.DefaultTableCellRenderer;

import phasereditor.chains.core.ChainItem;
import phasereditor.chains.core.ChainsModel;
import phasereditor.chains.core.Line;
import phasereditor.chains.core.Match;
import phasereditor.inspect.core.jsdoc.PhaserMethod;
import rayo.ui.Icons;
import rayo.ui.Workbench;

public class ChainsView extends JPanel {
	private static final long serialVersionUID = 1L;

	private JTable _table;

	private JTextField _searchText;

	private Object _query;

	public ChainsView() {
		setLayout(new BorderLayout());

		Font font = getCodeFont();
		{
			_table = new JTable() {
				private static final long serialVersionUID = 1L;

				@Override
				protected void processMouseEvent(MouseEvent e) {
					super.processMouseEvent(e);

					if (e.getID() == MouseEvent.MOUSE_CLICKED && e.getClickCount() == 2) {
						rowClicked();
					}
				}
			};

			Color color = _table.getSelectionBackground();
			String bg = "rgb(" + color.getRed() + "," + color.getGreen() + "," + color.getBlue() + ")";

			color = _table.getSelectionForeground();
			String fg = "rgb(" + color.getRed() + "," + color.getGreen() + "," + color.getBlue() + ")";

			DefaultTableCellRenderer renderer = new DefaultTableCellRenderer() {
				private static final long serialVersionUID = 1L;

				@Override
				public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,
						boolean hasFocus, int row, int column) {
					JLabel label = (JLabel) super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row,
							column);

					Match match = (Match) value;
					String text = "";
					if (match.item instanceof ChainItem) {
						ChainItem item = (ChainItem) match.item;
						String chain = item.getDisplay();
						text = getLabelText(match, chain, item.getDepth() > 1);
						if (chain.startsWith("new ")) {
							label.setIcon(Icons.getPhaserMemberIcon(PhaserMethod.class));
						} else {
							label.setIcon(Icons.getPhaserMemberIcon(item.getPhaserMember()));
						}
					} else if (match.item instanceof Line) {
						Line line = (Line) match.item;
						text = getLabelText(match, line.text, false);
						text += "[" + line.filename + " - " + line.linenum + "]";
						label.setIcon(Icons.getFileIcon());
					} else {
						String line = (String) match.item;
						text = getLabelText(match, line, false);
						label.setIcon(Icons.getFileIcon());
					}
					label.setText(text);
					return label;
				}

				private String getLabelText(Match match, String line, boolean italic) {
					StringBuilder sb = new StringBuilder();

					String line2 = line.replace("|", " | ");

					int a = match.start;
					int b = a + match.length;

					sb.append("");
					if (italic) {
						sb.append("");
					}
					sb.append(line2.substring(0, a));
					sb.append("");
					sb.append(line2.substring(a, b) + "");
					sb.append(line2.substring(b));

					return sb.toString();
				}
			};
			_table.setTableHeader(null);
			_table.setFont(font);
			_table.setDefaultRenderer(Object.class, renderer);
		}
		_searchText = new JTextField();
		_searchText.setFont(font);
		_searchText.setText("game.load.");
		_searchText.addKeyListener(new KeyAdapter() {
			@SuppressWarnings("synthetic-access")
			@Override
			public void keyReleased(KeyEvent e) {
				updateFromText();
			}
		});
		add(_searchText, BorderLayout.NORTH);
		add(new JScrollPane(_table), BorderLayout.CENTER);

		Workbench.getInstance().executeOnReady(this::modelIsReady);
	}

	protected void rowClicked() {
		int row = _table.getSelectedRow();
		if (row == -1) {
			return;
		}
		Match match = (Match) _table.getModel().getValueAt(row, 0);
		Object item = match.item;
		if (item instanceof ChainItem) {
			Workbench.getInstance().getDocView().display(((ChainItem) item).getPhaserMember());
		} else if (item instanceof Line) {
			Line line = (Line) item;
			String path = line.filename;
			openUrl(path, line.linenum);

		} else if (item instanceof String) {
			openUrl((String) item, 0);
		}
	}

	private static void openUrl(String path, int linenum) {
		try {
			String path2 = path.replace("+", " ").replace(" ", "%20");
			if (path2.indexOf("labs") != 0) {
				path2 = "examples/" + path2;
			}
			String href = "https://github.com/photonstorm/phaser-examples/blob/master/" + path2 + "#L" + linenum;
			Desktop.getDesktop().browse(new URI(href));
		} catch (IOException | URISyntaxException e) {
			e.printStackTrace();
			showMessageDialog(null, e, "Browser", ERROR_MESSAGE);
		}
	}

	private void updateFromText() {
		String query = _searchText.getText();

		if (_query != null && query.equals(_query)) {
			return;
		}
		_query = query;

		ChainsModel model = ChainsModel.getInstance();
		List<Match> chainsMathes = model.searchChains(query, 100);
		List<Match> examplesMatches = model.searchExamples(query, 100);
		_table.setModel(new ChainsTableModel(chainsMathes, examplesMatches));
	}

	private void modelIsReady() {
		updateFromText();
	}
}

redpajama_set_name: RedPajamaGithub


text:
<?php

namespace BingAds\CampaignManagement;

/**
 * Retrieves detailed information about all the targets in your target library.
 * @link http://msdn.microsoft.com/en-us/library/dn236308(v=msads.90).aspx GetTargetsInfoFromLibraryRequest Request Object
 */
final class GetTargetsInfoFromLibraryRequest
{
}


text:
package org.mockito.internal.util.reflection;

public class DummyParentClassForTests {

    @SuppressWarnings("unused")//I know, I know. We're doing nasty reflection hacks here...
    private String somePrivateField;
}


text:
var fs = require('fs'),
    vows = require('vows'),
    assert = require('assert'),
    nodemock = require('nodemock'),
    sqlite3 = require('sqlite3');

var db = require('../lib/db.js')

function db_file_setup(){
  var test_db_filename = 'db/test.db'
  if(fs.existsSync(test_db_filename)){
    fs.unlinkSync(test_db_filename)
  }
  db.setup(sqlite3, test_db_filename)
}

db_file_setup()

vows.describe('db').addBatch({
  'sqlite3': {
    topic: db,
    'setup': function(db){
      assert(db.connected)
    }
  },
  'missing load_block_hash': {
    topic: function(){
      db.save_block_hash(null, function(){
        db.load_block_hash(this.callback)
      })
    },
    'no hash': function(hash){
      assert.isUndefined(hash)
    }
  },
  'existing load_block_hash': {
    topic: function(){
      db.save_block_hash("00abc", function(){
        db.load_block_hash(this.callback)
      })
    },
    'existing hash': function(hash){
      assert.equal(hash, 1)
    }
  },
  'save_block_hash': {
    topic: function(){
      db.save_block_hash("00abc", this.callback)
    },
    'saved': function(hash){
      assert(true)
    },
  }

}).export(module)


text:
/* Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.camunda.bpm.engine.rest.dto.runtime;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.Response.Status;

import org.camunda.bpm.engine.ProcessEngine;
import org.camunda.bpm.engine.rest.dto.AbstractQueryDto;
import org.camunda.bpm.engine.rest.dto.CamundaQueryParam;
import org.camunda.bpm.engine.rest.dto.VariableQueryParameterDto;
import org.camunda.bpm.engine.rest.dto.converter.StringArrayConverter;
import org.camunda.bpm.engine.rest.dto.converter.VariableListConverter;
import org.camunda.bpm.engine.rest.exception.InvalidRequestException;
import org.camunda.bpm.engine.runtime.VariableInstanceQuery;

import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * @author roman.smirnov
 */
public class VariableInstanceQueryDto extends AbstractQueryDto<VariableInstanceQuery> {

  private static final String SORT_BY_VARIABLE_NAME_VALUE = "variableName";
  private static final String SORT_BY_VARIABLE_TYPE_VALUE = "variableType";
  private static final String SORT_BY_ACTIVITY_INSTANCE_ID_VALUE = "activityInstanceId";

  private static final List<String> VALID_SORT_BY_VALUES;
  static {
    VALID_SORT_BY_VALUES = new ArrayList<String>();
    VALID_SORT_BY_VALUES.add(SORT_BY_VARIABLE_NAME_VALUE);
    VALID_SORT_BY_VALUES.add(SORT_BY_VARIABLE_TYPE_VALUE);
    VALID_SORT_BY_VALUES.add(SORT_BY_ACTIVITY_INSTANCE_ID_VALUE);
  }

  protected String variableName;
  protected String variableNameLike;
  protected List<VariableQueryParameterDto> variableValues;
  protected String[] executionIdIn;
  protected String[] processInstanceIdIn;
  protected String[] caseExecutionIdIn;
  protected String[] caseInstanceIdIn;
  protected String[] taskIdIn;
  protected String[] variableScopeIdIn;
  protected String[] activityInstanceIdIn;

  public VariableInstanceQueryDto() {}

  public VariableInstanceQueryDto(ObjectMapper objectMapper, MultivaluedMap<String, String> queryParameters) {
    super(objectMapper, queryParameters);
  }

  @CamundaQueryParam("variableName")
  public void setVariableName(String variableName) {
    this.variableName = variableName;
  }

  @CamundaQueryParam("variableNameLike")
  public void setVariableNameLike(String variableNameLike) {
    this.variableNameLike = variableNameLike;
  }

  @CamundaQueryParam(value = "variableValues", converter = VariableListConverter.class)
  public void setVariableValues(List<VariableQueryParameterDto> variableValues) {
    this.variableValues = variableValues;
  }

  @CamundaQueryParam(value="executionIdIn", converter = StringArrayConverter.class)
  public void setExecutionIdIn(String[] executionIdIn) {
    this.executionIdIn = executionIdIn;
  }

  @CamundaQueryParam(value="processInstanceIdIn", converter = StringArrayConverter.class)
  public void setProcessInstanceIdIn(String[] processInstanceIdIn) {
    this.processInstanceIdIn = processInstanceIdIn;
  }

  @CamundaQueryParam(value="caseExecutionIdIn", converter = StringArrayConverter.class)
  public void setCaseExecutionIdIn(String[] caseExecutionIdIn) {
    this.caseExecutionIdIn = caseExecutionIdIn;
  }

  @CamundaQueryParam(value="caseInstanceIdIn", converter = StringArrayConverter.class)
  public void setCaseInstanceIdIn(String[] caseInstanceIdIn) {
    this.caseInstanceIdIn = caseInstanceIdIn;
  }

  @CamundaQueryParam(value="taskIdIn", converter = StringArrayConverter.class)
  public void setTaskIdIn(String[] taskIdIn) {
    this.taskIdIn = taskIdIn;
  }

  @CamundaQueryParam(value="variableScopeIdIn", converter = StringArrayConverter.class)
  public void setVariableScopeIdIn(String[] variableScopeIdIn) {
    this.variableScopeIdIn = variableScopeIdIn;
  }

  @CamundaQueryParam(value="activityInstanceIdIn", converter = StringArrayConverter.class)
  public void setActivityInstanceIdIn(String[] activityInstanceIdIn) {
    this.activityInstanceIdIn = activityInstanceIdIn;
  }

  @Override
  protected boolean isValidSortByValue(String value) {
    return VALID_SORT_BY_VALUES.contains(value);
  }

  @Override
  protected VariableInstanceQuery createNewQuery(ProcessEngine engine) {
    return engine.getRuntimeService().createVariableInstanceQuery();
  }

  @Override
  protected void applyFilters(VariableInstanceQuery query) {
    if (variableName != null) {
      query.variableName(variableName);
    }

    if (variableNameLike != null) {
      query.variableNameLike(variableNameLike);
    }

    if (variableValues != null) {
      for (VariableQueryParameterDto variableQueryParam : variableValues) {
        String variableName = variableQueryParam.getName();
        String op = variableQueryParam.getOperator();
        Object variableValue = variableQueryParam.resolveValue(objectMapper);

        if (op.equals(VariableQueryParameterDto.EQUALS_OPERATOR_NAME)) {
          query.variableValueEquals(variableName, variableValue);
        } else if (op.equals(VariableQueryParameterDto.GREATER_THAN_OPERATOR_NAME)) {
          query.variableValueGreaterThan(variableName, variableValue);
        } else if (op.equals(VariableQueryParameterDto.GREATER_THAN_OR_EQUALS_OPERATOR_NAME)) {
          query.variableValueGreaterThanOrEqual(variableName, variableValue);
        } else if (op.equals(VariableQueryParameterDto.LESS_THAN_OPERATOR_NAME)) {
          query.variableValueLessThan(variableName, variableValue);
        } else if (op.equals(VariableQueryParameterDto.LESS_THAN_OR_EQUALS_OPERATOR_NAME)) {
          query.variableValueLessThanOrEqual(variableName, variableValue);
        } else if (op.equals(VariableQueryParameterDto.NOT_EQUALS_OPERATOR_NAME)) {
          query.variableValueNotEquals(variableName, variableValue);
        } else if (op.equals(VariableQueryParameterDto.LIKE_OPERATOR_NAME)) {
          query.variableValueLike(variableName, String.valueOf(variableValue));
        } else {
          throw new InvalidRequestException(Status.BAD_REQUEST, "Invalid variable comparator specified: " + op);
        }
      }
    }

    if (executionIdIn != null && executionIdIn.length > 0) {
      query.executionIdIn(executionIdIn);
    }

    if (processInstanceIdIn != null && processInstanceIdIn.length > 0) {
      query.processInstanceIdIn(processInstanceIdIn);
    }

    if (caseExecutionIdIn != null && caseExecutionIdIn.length > 0) {
      query.caseExecutionIdIn(caseExecutionIdIn);
    }

    if (caseInstanceIdIn != null && caseInstanceIdIn.length > 0) {
      query.caseInstanceIdIn(caseInstanceIdIn);
    }

    if (taskIdIn != null && taskIdIn.length > 0) {
      query.taskIdIn(taskIdIn);
    }

    if (variableScopeIdIn != null && variableScopeIdIn.length > 0) {
      query.variableScopeIdIn(variableScopeIdIn);
    }

    if (activityInstanceIdIn != null && activityInstanceIdIn.length > 0) {
      query.activityInstanceIdIn(activityInstanceIdIn);
    }
  }

  @Override
  protected void applySortBy(VariableInstanceQuery query, String sortBy, Map<String, Object> parameters, ProcessEngine engine) {
    if (sortBy.equals(SORT_BY_VARIABLE_NAME_VALUE)) {
      query.orderByVariableName();
    } else if (sortBy.equals(SORT_BY_VARIABLE_TYPE_VALUE)) {
      query.orderByVariableType();
    } else if (sortBy.equals(SORT_BY_ACTIVITY_INSTANCE_ID_VALUE)) {
      query.orderByActivityInstanceId();
    }
  }

}


text:
package org.apache.camel.builder.endpoint.dsl;

import javax.annotation.Generated;
import org.apache.camel.ExchangePattern;
import org.apache.camel.builder.EndpointConsumerBuilder;
import org.apache.camel.builder.EndpointProducerBuilder;
import org.apache.camel.builder.endpoint.AbstractEndpointBuilder;
import org.apache.camel.spi.ExceptionHandler;

/**
 * The cmis component uses the Apache Chemistry client API and allows you to
 * add/read nodes to/from a CMIS compliant content repositories.
 *
 * Generated by camel-package-maven-plugin - do not edit this file!
 */
@Generated("org.apache.camel.maven.packaging.EndpointDslMojo")
public interface CMISEndpointBuilderFactory {

    /**
     * Builder for endpoint consumers for the CMIS component.
     */
    public interface CMISEndpointConsumerBuilder
            extends
                EndpointConsumerBuilder {
        default AdvancedCMISEndpointConsumerBuilder advanced() {
            return (AdvancedCMISEndpointConsumerBuilder) this;
        }
        /**
         * Number of nodes to retrieve per page.
         *
         * The option is a: int type.
         *
         * Default: 100
         * Group: common
         */
        default CMISEndpointConsumerBuilder pageSize(int pageSize) {
            doSetProperty("pageSize", pageSize);
            return this;
        }
        /**
         * Number of nodes to retrieve per page.
         *
         * The option will be converted to a int type.
         *
         * Default: 100
         * Group: common
         */
        default CMISEndpointConsumerBuilder pageSize(String pageSize) {
            doSetProperty("pageSize", pageSize);
            return this;
        }
        /**
         * If set to true, the content of document node will be retrieved in
         * addition to the properties.
         *
         * The option is a: boolean type.
         *
         * Default: false
         * Group: common
         */
        default CMISEndpointConsumerBuilder readContent(boolean readContent) {
            doSetProperty("readContent", readContent);
            return this;
        }
        /**
         * If set to true, the content of document node will be retrieved in
         * addition to the properties.
         *
         * The option will be converted to a boolean type.
         *
         * Default: false
         * Group: common
         */
        default CMISEndpointConsumerBuilder readContent(String readContent) {
            doSetProperty("readContent", readContent);
            return this;
        }
        /**
         * Max number of nodes to read.
         *
         * The option is a: int type.
         *
         * Group: common
         */
        default CMISEndpointConsumerBuilder readCount(int readCount) {
            doSetProperty("readCount", readCount);
            return this;
        }
        /**
         * Max number of nodes to read.
         *
         * The option will be converted to a int type.
         *
         * Group: common
         */
        default CMISEndpointConsumerBuilder readCount(String readCount) {
            doSetProperty("readCount", readCount);
            return this;
        }
        /**
         * The Id of the repository to use. If not specified the first available
         * repository is used.
         *
         * The option is a: java.lang.String type.
         *
         * Group: common
         */
        default CMISEndpointConsumerBuilder repositoryId(String repositoryId) {
            doSetProperty("repositoryId", repositoryId);
            return this;
        }
        /**
         * Allows for bridging the consumer to the Camel routing Error Handler,
         * which mean any exceptions occurred while the consumer is trying to
         * pickup incoming messages, or the likes, will now be processed as a
         * message and handled by the routing Error Handler. By default the
         * consumer will use the org.apache.camel.spi.ExceptionHandler to deal
         * with exceptions, that will be logged at WARN or ERROR level and
         * ignored.
         *
         * The option is a: boolean type.
         *
         * Default: false
         * Group: consumer
         */
        default CMISEndpointConsumerBuilder bridgeErrorHandler(
                boolean bridgeErrorHandler) {
            doSetProperty("bridgeErrorHandler", bridgeErrorHandler);
            return this;
        }
        /**
         * Allows for bridging the consumer to the Camel routing Error Handler,
         * which mean any exceptions occurred while the consumer is trying to
         * pickup incoming messages, or the likes, will now be processed as a
         * message and handled by the routing Error Handler. By default the
         * consumer will use the org.apache.camel.spi.ExceptionHandler to deal
         * with exceptions, that will be logged at WARN or ERROR level and
         * ignored.
         *
         * The option will be converted to a boolean type.
         *
         * Default: false
         * Group: consumer
         */
        default CMISEndpointConsumerBuilder bridgeErrorHandler(
                String bridgeErrorHandler) {
            doSetProperty("bridgeErrorHandler", bridgeErrorHandler);
            return this;
        }
        /**
         * The cmis query to execute against the repository. If not specified,
         * the consumer will retrieve every node from the content repository by
         * iterating the content tree recursively.
         *
         * The option is a: java.lang.String type.
         *
         * Group: consumer
         */
        default CMISEndpointConsumerBuilder query(String query) {
            doSetProperty("query", query);
            return this;
        }
        /**
         * Password for the cmis repository.
         *
         * The option is a: java.lang.String type.
         *
         * Group: security
         */
        default CMISEndpointConsumerBuilder password(String password) {
            doSetProperty("password", password);
            return this;
        }
        /**
         * Username for the cmis repository.
         *
         * The option is a: java.lang.String type.
         *
         * Group: security
         */
        default CMISEndpointConsumerBuilder username(String username) {
            doSetProperty("username", username);
            return this;
        }
    }

    /**
     * Advanced builder for endpoint consumers for the CMIS component.
     */
    public interface AdvancedCMISEndpointConsumerBuilder
            extends
                EndpointConsumerBuilder {
        default CMISEndpointConsumerBuilder basic() {
            return (CMISEndpointConsumerBuilder) this;
        }
        /**
         * To let the consumer use a custom ExceptionHandler. Notice if the
         * option bridgeErrorHandler is enabled then this option is not in use.
         * By default the consumer will deal with exceptions, that will be
         * logged at WARN or ERROR level and ignored.
         *
         * The option is a: org.apache.camel.spi.ExceptionHandler
         * type.
         *
         * Group: consumer (advanced)
         */
        default AdvancedCMISEndpointConsumerBuilder exceptionHandler(
                ExceptionHandler exceptionHandler) {
            doSetProperty("exceptionHandler", exceptionHandler);
            return this;
        }
        /**
         * To let the consumer use a custom ExceptionHandler. Notice if the
         * option bridgeErrorHandler is enabled then this option is not in use.
         * By default the consumer will deal with exceptions, that will be
         * logged at WARN or ERROR level and ignored.
         *
         * The option will be converted to a
         * org.apache.camel.spi.ExceptionHandler type.
         *
         * Group: consumer (advanced)
         */
        default AdvancedCMISEndpointConsumerBuilder exceptionHandler(
                String exceptionHandler) {
            doSetProperty("exceptionHandler", exceptionHandler);
            return this;
        }
        /**
         * Sets the exchange pattern when the consumer creates an exchange.
         *
         * The option is a: org.apache.camel.ExchangePattern type.
         *
         * Group: consumer (advanced)
         */
        default AdvancedCMISEndpointConsumerBuilder exchangePattern(
                ExchangePattern exchangePattern) {
            doSetProperty("exchangePattern", exchangePattern);
            return this;
        }
        /**
         * Sets the exchange pattern when the consumer creates an exchange.
         *
         * The option will be converted to a
         * org.apache.camel.ExchangePattern type.
         *
         * Group: consumer (advanced)
         */
        default AdvancedCMISEndpointConsumerBuilder exchangePattern(
                String exchangePattern) {
            doSetProperty("exchangePattern", exchangePattern);
            return this;
        }
        /**
         * Whether the endpoint should use basic property binding (Camel 2.x) or
         * the newer property binding with additional capabilities.
         *
         * The option is a: boolean type.
         *
         * Default: false
         * Group: advanced
         */
        default AdvancedCMISEndpointConsumerBuilder basicPropertyBinding(
                boolean basicPropertyBinding) {
            doSetProperty("basicPropertyBinding", basicPropertyBinding);
            return this;
        }
        /**
         * Whether the endpoint should use basic property binding (Camel 2.x) or
         * the newer property binding with additional capabilities.
         *
         * The option will be converted to a boolean type.
         *
         * Default: false
         * Group: advanced
         */
        default AdvancedCMISEndpointConsumerBuilder basicPropertyBinding(
                String basicPropertyBinding) {
            doSetProperty("basicPropertyBinding", basicPropertyBinding);
            return this;
        }
        /**
         * To use a custom CMISSessionFacadeFactory to create the
         * CMISSessionFacade instances.
         *
         * The option is a:
         * org.apache.camel.component.cmis.CMISSessionFacadeFactory
         * type.
         *
         * Group: advanced
         */
        default AdvancedCMISEndpointConsumerBuilder sessionFacadeFactory(
                Object sessionFacadeFactory) {
            doSetProperty("sessionFacadeFactory", sessionFacadeFactory);
            return this;
        }
        /**
         * To use a custom CMISSessionFacadeFactory to create the
         * CMISSessionFacade instances.
         *
         * The option will be converted to a
         * org.apache.camel.component.cmis.CMISSessionFacadeFactory
         * type.
         *
         * Group: advanced
         */
        default AdvancedCMISEndpointConsumerBuilder sessionFacadeFactory(
                String sessionFacadeFactory) {
            doSetProperty("sessionFacadeFactory", sessionFacadeFactory);
            return this;
        }
        /**
         * Sets whether synchronous processing should be strictly used, or Camel
         * is allowed to use asynchronous processing (if supported).
         *
         * The option is a: boolean type.
         *
         * Default: false
         * Group: advanced
         */
        default AdvancedCMISEndpointConsumerBuilder synchronous(
                boolean synchronous) {
            doSetProperty("synchronous", synchronous);
            return this;
        }
        /**
         * Sets whether synchronous processing should be strictly used, or Camel
         * is allowed to use asynchronous processing (if supported).
         *
         * The option will be converted to a boolean type.
         *
         * Default: false
         * Group: advanced
         */
        default AdvancedCMISEndpointConsumerBuilder synchronous(
                String synchronous) {
            doSetProperty("synchronous", synchronous);
            return this;
        }
    }

    /**
     * Builder for endpoint producers for the CMIS component.
     */
    public interface CMISEndpointProducerBuilder
            extends
                EndpointProducerBuilder {
        default AdvancedCMISEndpointProducerBuilder advanced() {
            return (AdvancedCMISEndpointProducerBuilder) this;
        }
        /**
         * Number of nodes to retrieve per page.
         *
         * The option is a: int type.
         *
         * Default: 100
         * Group: common
         */
        default CMISEndpointProducerBuilder pageSize(int pageSize) {
            doSetProperty("pageSize", pageSize);
            return this;
        }
        /**
         * Number of nodes to retrieve per page.
         *
         * The option will be converted to a int type.
         *
         * Default: 100
         * Group: common
         */
        default CMISEndpointProducerBuilder pageSize(String pageSize) {
            doSetProperty("pageSize", pageSize);
            return this;
        }
        /**
         * If set to true, the content of document node will be retrieved in
         * addition to the properties.
         *
         * The option is a: boolean type.
         *
         * Default: false
         * Group: common
         */
        default CMISEndpointProducerBuilder readContent(boolean readContent) {
            doSetProperty("readContent", readContent);
            return this;
        }
        /**
         * If set to true, the content of document node will be retrieved in
         * addition to the properties.
         *
         * The option will be converted to a boolean type.
         *
         * Default: false
         * Group: common
         */
        default CMISEndpointProducerBuilder readContent(String readContent) {
            doSetProperty("readContent", readContent);
            return this;
        }
        /**
         * Max number of nodes to read.
         *
         * The option is a: int type.
         *
         * Group: common
         */
        default CMISEndpointProducerBuilder readCount(int readCount) {
            doSetProperty("readCount", readCount);
            return this;
        }
        /**
         * Max number of nodes to read.
         *
         * The option will be converted to a int type.
         *
         * Group: common
         */
        default CMISEndpointProducerBuilder readCount(String readCount) {
            doSetProperty("readCount", readCount);
            return this;
        }
        /**
         * The Id of the repository to use. If not specified the first available
         * repository is used.
         *
         * The option is a: java.lang.String type.
         *
         * Group: common
         */
        default CMISEndpointProducerBuilder repositoryId(String repositoryId) {
            doSetProperty("repositoryId", repositoryId);
            return this;
        }
        /**
         * Whether the producer should be started lazy (on the first message).
         * By starting lazy you can use this to allow CamelContext and routes to
         * startup in situations where a producer may otherwise fail during
         * starting and cause the route to fail being started. By deferring this
         * startup to be lazy then the startup failure can be handled during
         * routing messages via Camel's routing error handlers. Beware that when
         * the first message is processed then creating and starting the
         * producer may take a little time and prolong the total processing time
         * of the processing.
         *
         * The option is a: boolean type.
         *
         * Default: false
         * Group: producer
         */
        default CMISEndpointProducerBuilder lazyStartProducer(
                boolean lazyStartProducer) {
            doSetProperty("lazyStartProducer", lazyStartProducer);
            return this;
        }
        /**
         * Whether the producer should be started lazy (on the first message).
         * By starting lazy you can use this to allow CamelContext and routes to
         * startup in situations where a producer may otherwise fail during
         * starting and cause the route to fail being started. By deferring this
         * startup to be lazy then the startup failure can be handled during
         * routing messages via Camel's routing error handlers. Beware that when
         * the first message is processed then creating and starting the
         * producer may take a little time and prolong the total processing time
         * of the processing.
         *
         * The option will be converted to a boolean type.
         *
         * Default: false
         * Group: producer
         */
        default CMISEndpointProducerBuilder lazyStartProducer(
                String lazyStartProducer) {
            doSetProperty("lazyStartProducer", lazyStartProducer);
            return this;
        }
        /**
         * If true, will execute the cmis query from the message body and return
         * result, otherwise will create a node in the cmis repository.
         *
         * The option is a: boolean type.
         *
         * Default: false
         * Group: producer
         */
        default CMISEndpointProducerBuilder queryMode(boolean queryMode) {
            doSetProperty("queryMode", queryMode);
            return this;
        }
        /**
         * If true, will execute the cmis query from the message body and return
         * result, otherwise will create a node in the cmis repository.
         *
         * The option will be converted to a boolean type.
         *
         * Default: false
         * Group: producer
         */
        default CMISEndpointProducerBuilder queryMode(String queryMode) {
            doSetProperty("queryMode", queryMode);
            return this;
        }
        /**
         * Password for the cmis repository.
         *
         * The option is a: java.lang.String type.
         *
         * Group: security
         */
        default CMISEndpointProducerBuilder password(String password) {
            doSetProperty("password", password);
            return this;
        }
        /**
         * Username for the cmis repository.
         *
         * The option is a: java.lang.String type.
         *
         * Group: security
         */
        default CMISEndpointProducerBuilder username(String username) {
            doSetProperty("username", username);
            return this;
        }
    }

    /**
     * Advanced builder for endpoint producers for the CMIS component.
     */
    public interface AdvancedCMISEndpointProducerBuilder
            extends
                EndpointProducerBuilder {
        default CMISEndpointProducerBuilder basic() {
            return (CMISEndpointProducerBuilder) this;
        }
        /**
         * Whether the endpoint should use basic property binding (Camel 2.x) or
         * the newer property binding with additional capabilities.
         *
         * The option is a: boolean type.
         *
         * Default: false
         * Group: advanced
         */
        default AdvancedCMISEndpointProducerBuilder basicPropertyBinding(
                boolean basicPropertyBinding) {
            doSetProperty("basicPropertyBinding", basicPropertyBinding);
            return this;
        }
        /**
         * Whether the endpoint should use basic property binding (Camel 2.x) or
         * the newer property binding with additional capabilities.
         *
         * The option will be converted to a boolean type.
         *
         * Default: false
         * Group: advanced
         */
        default AdvancedCMISEndpointProducerBuilder basicPropertyBinding(
                String basicPropertyBinding) {
            doSetProperty("basicPropertyBinding", basicPropertyBinding);
            return this;
        }
        /**
         * To use a custom CMISSessionFacadeFactory to create the
         * CMISSessionFacade instances.
         *
         * The option is a:
         * org.apache.camel.component.cmis.CMISSessionFacadeFactory
         * type.
         *
         * Group: advanced
         */
        default AdvancedCMISEndpointProducerBuilder sessionFacadeFactory(
                Object sessionFacadeFactory) {
            doSetProperty("sessionFacadeFactory", sessionFacadeFactory);
            return this;
        }
        /**
         * To use a custom CMISSessionFacadeFactory to create the
         * CMISSessionFacade instances.
         *
         * The option will be converted to a
         * org.apache.camel.component.cmis.CMISSessionFacadeFactory
         * type.
         *
         * Group: advanced
         */
        default AdvancedCMISEndpointProducerBuilder sessionFacadeFactory(
                String sessionFacadeFactory) {
            doSetProperty("sessionFacadeFactory", sessionFacadeFactory);
            return this;
        }
        /**
         * Sets whether synchronous processing should be strictly used, or Camel
         * is allowed to use asynchronous processing (if supported).
         *
         * The option is a: boolean type.
         *
         * Default: false
         * Group: advanced
         */
        default AdvancedCMISEndpointProducerBuilder synchronous(
                boolean synchronous) {
            doSetProperty("synchronous", synchronous);
            return this;
        }
        /**
         * Sets whether synchronous processing should be strictly used, or Camel
         * is allowed to use asynchronous processing (if supported).
         *
         * The option will be converted to a boolean type.
         *
         * Default: false
         * Group: advanced
         */
        default AdvancedCMISEndpointProducerBuilder synchronous(
                String synchronous) {
            doSetProperty("synchronous", synchronous);
            return this;
        }
    }

    /**
     * Builder for endpoint for the CMIS component.
     */
    public interface CMISEndpointBuilder
            extends
                CMISEndpointConsumerBuilder,
                CMISEndpointProducerBuilder {
        default AdvancedCMISEndpointBuilder advanced() {
            return (AdvancedCMISEndpointBuilder) this;
        }
        /**
         * Number of nodes to retrieve per page.
         *
         * The option is a: int type.
         *
         * Default: 100
         * Group: common
         */
        default CMISEndpointBuilder pageSize(int pageSize) {
            doSetProperty("pageSize", pageSize);
            return this;
        }
        /**
         * Number of nodes to retrieve per page.
         *
         * The option will be converted to a int type.
         *
         * Default: 100
         * Group: common
         */
        default CMISEndpointBuilder pageSize(String pageSize) {
            doSetProperty("pageSize", pageSize);
            return this;
        }
        /**
         * If set to true, the content of document node will be retrieved in
         * addition to the properties.
         *
         * The option is a: boolean type.
         *
         * Default: false
         * Group: common
         */
        default CMISEndpointBuilder readContent(boolean readContent) {
            doSetProperty("readContent", readContent);
            return this;
        }
        /**
         * If set to true, the content of document node will be retrieved in
         * addition to the properties.
         *
         * The option will be converted to a boolean type.
         *
         * Default: false
         * Group: common
         */
        default CMISEndpointBuilder readContent(String readContent) {
            doSetProperty("readContent", readContent);
            return this;
        }
        /**
         * Max number of nodes to read.
         *
         * The option is a: int type.
         *
         * Group: common
         */
        default CMISEndpointBuilder readCount(int readCount) {
            doSetProperty("readCount", readCount);
            return this;
        }
        /**
         * Max number of nodes to read.
         *
         * The option will be converted to a int type.
         *
         * Group: common
         */
        default CMISEndpointBuilder readCount(String readCount) {
            doSetProperty("readCount", readCount);
            return this;
        }
        /**
         * The Id of the repository to use. If not specified the first available
         * repository is used.
         *
         * The option is a: java.lang.String type.
         *
         * Group: common
         */
        default CMISEndpointBuilder repositoryId(String repositoryId) {
            doSetProperty("repositoryId", repositoryId);
            return this;
        }
        /**
         * Password for the cmis repository.
         *
         * The option is a: java.lang.String type.
         *
         * Group: security
         */
        default CMISEndpointBuilder password(String password) {
            doSetProperty("password", password);
            return this;
        }
        /**
         * Username for the cmis repository.
         *
         * The option is a: java.lang.String type.
         *
         * Group: security
         */
        default CMISEndpointBuilder username(String username) {
            doSetProperty("username", username);
            return this;
        }
    }

    /**
     * Advanced builder for endpoint for the CMIS component.
     */
    public interface AdvancedCMISEndpointBuilder
            extends
                AdvancedCMISEndpointConsumerBuilder,
                AdvancedCMISEndpointProducerBuilder {
        default CMISEndpointBuilder basic() {
            return (CMISEndpointBuilder) this;
        }
        /**
         * Whether the endpoint should use basic property binding (Camel 2.x) or
         * the newer property binding with additional capabilities.
         *
         * The option is a: boolean type.
         *
         * Default: false
         * Group: advanced
         */
        default AdvancedCMISEndpointBuilder basicPropertyBinding(
                boolean basicPropertyBinding) {
            doSetProperty("basicPropertyBinding", basicPropertyBinding);
            return this;
        }
        /**
         * Whether the endpoint should use basic property binding (Camel 2.x) or
         * the newer property binding with additional capabilities.
         *
         * The option will be converted to a boolean type.
         *
         * Default: false
         * Group: advanced
         */
        default AdvancedCMISEndpointBuilder basicPropertyBinding(
                String basicPropertyBinding) {
            doSetProperty("basicPropertyBinding", basicPropertyBinding);
            return this;
        }
        /**
         * To use a custom CMISSessionFacadeFactory to create the
         * CMISSessionFacade instances.
         *
         * The option is a:
         * org.apache.camel.component.cmis.CMISSessionFacadeFactory
         * type.
         *
         * Group: advanced
         */
        default AdvancedCMISEndpointBuilder sessionFacadeFactory(
                Object sessionFacadeFactory) {
            doSetProperty("sessionFacadeFactory", sessionFacadeFactory);
            return this;
        }
        /**
         * To use a custom CMISSessionFacadeFactory to create the
         * CMISSessionFacade instances.
         *
         * The option will be converted to a
         * org.apache.camel.component.cmis.CMISSessionFacadeFactory
         * type.
         *
         * Group: advanced
         */
        default AdvancedCMISEndpointBuilder sessionFacadeFactory(
                String sessionFacadeFactory) {
            doSetProperty("sessionFacadeFactory", sessionFacadeFactory);
            return this;
        }
        /**
         * Sets whether synchronous processing should be strictly used, or Camel
         * is allowed to use asynchronous processing (if supported).
         *
         * The option is a: boolean type.
         *
         * Default: false
         * Group: advanced
         */
        default AdvancedCMISEndpointBuilder synchronous(boolean synchronous) {
            doSetProperty("synchronous", synchronous);
            return this;
        }
        /**
         * Sets whether synchronous processing should be strictly used, or Camel
         * is allowed to use asynchronous processing (if supported).
         *
         * The option will be converted to a boolean type.
         *
         * Default: false
         * Group: advanced
         */
        default AdvancedCMISEndpointBuilder synchronous(String synchronous) {
            doSetProperty("synchronous", synchronous);
            return this;
        }
    }

    public interface CMISBuilders {
        /**
         * CMIS (camel-cmis)
         * The cmis component uses the Apache Chemistry client API and allows
         * you to add/read nodes to/from a CMIS compliant content repositories.
         *
         * Category: cms,database
         * Since: 2.11
         * Maven coordinates: org.apache.camel:camel-cmis
         *
         * Syntax: cmis:cmsUrl
         *
         * Path parameter: cmsUrl (required)
         * URL to the cmis repository
         */
        default CMISEndpointBuilder cmis(String path) {
            return CMISEndpointBuilderFactory.cmis(path);
        }
    }
    /**
     * CMIS (camel-cmis)
     * The cmis component uses the Apache Chemistry client API and allows you to
     * add/read nodes to/from a CMIS compliant content repositories.
     *
     * Category: cms,database
     * Since: 2.11
     * Maven coordinates: org.apache.camel:camel-cmis
     *
     * Syntax: cmis:cmsUrl
     *
     * Path parameter: cmsUrl (required)
     * URL to the cmis repository
     */
    static CMISEndpointBuilder cmis(String path) {
        class CMISEndpointBuilderImpl extends AbstractEndpointBuilder implements CMISEndpointBuilder, AdvancedCMISEndpointBuilder {
            public CMISEndpointBuilderImpl(String path) {
                super("cmis", path);
            }
        }
        return new CMISEndpointBuilderImpl(path);
    }
}


text:
![5 stars](../../images/ic_star_black_18dp_1x.png)![5 stars](../../images/ic_star_black_18dp_1x.png)![5 stars](../../images/ic_star_black_18dp_1x.png)![5 stars](../../images/ic_star_black_18dp_1x.png)![5 stars](../../images/ic_star_black_18dp_1x.png) 1

To use the Life Notifications skill, try saying...

* *Alexa ask life notifications for last notifications*

* *Alexa ask life notifications for clear*

* *Alexa open life notifications*

Get your mobile notifications

Installation

- Enable this Skill
- Ask for help saying "Alexa ask life notifications for last notifications"
- Check the skill card and copy the userId code
- Download the App you can read on the card
- Install it, paste the userId code on settings / userId box
- Enable the App to read your notifications
- Send a test notification

Just use these commands:
- clear: delete all your stored notifications
- notifications: read all your stored notifications

Configuration
- You have a lot of options at settings, try them

***

### Skill Details

* **Invocation Name:** life notifications
* **Category:** null
* **ID:** amzn1.ask.skill.76a9a2d3-3777-4f07-b46d-3231204df4e1
* **ASIN:** B01L6PM35M
* **Author:** pacosal
* **Release Date:** November 16, 2016 @ 02:06:41
* **In-App Purchasing:** No


text:
java-ee-examples
================

This is a repository for storing examples of Java EE


text:
#ifndef __LINE_H__
#define __LINE_H__
#include "Point.h"

typedef struct {
    Point start;
    Point end;
} Line;

Line get_line(void);
void show_line(Line line);
void move_line_by_ref(Line *line);

#endif /* __LINE_H__ */


text:
import { EventEmitterInterface, PromiseReject, PromiseResolve, UnwrapPromise } from "shared/types/helpers";
import { delay as promiseDelay } from "shared/util";
import { CancellationError, CancellationToken } from "shared/utils/CancellationToken";
import EventEmitter from "vendor/events";

type JobCallback<T extends any[], R> = (job: Job<T, R>, ...args: T) => R;

class Job<T extends any[], R> {
    cancellationToken: CancellationToken<this>;
    id: number;
    resolve: PromiseResolve<UnwrapPromise<R>>;
    reject: PromiseReject;
    args: T;
    cancelId: number;
    promise: Promise<UnwrapPromise<R>> | null;
    constructor(id: number, resolve: PromiseResolve<UnwrapPromise<R>>, reject: PromiseReject, args: T) {
        this.id = id;
        this.resolve = resolve;
        this.reject = reject;
        this.args = args;
        this.cancelId = 0;
        this.promise = null;
        this.cancellationToken = new CancellationToken(this, `cancelId`);
    }

    cancel() {
        this.cancelId++;
    }

    isCancelled() {
        return this.cancellationToken.isCancelled();
    }
}

interface PromisedJob<T extends any[], R> extends Job<T, R> {
    promise: Promise<UnwrapPromise<R>>;
}

interface Opts<T extends any[], R> {
    parallelJobs?: number;
    delay?: number;
    jobCallback: JobCallback<T, R>;
}

export default interface JobProcessor<T extends any[], R>
    extends EventEmitterInterface<{
        jobComplete: (job: Job<T, R>) => void;
        allJobsComplete: () => void;
    }> {}

export default class JobProcessor<T extends any[], R> extends EventEmitter {
    _jobId: number;
    _delay: number;
    _parallelJobs: number;
    _queuedJobs: Job<T, R>[];
    _activeJobs: Job<T, R>[];
    _jobCallback: JobCallback<T, R>;
    _allJobsPersistedEmitted: boolean;
    constructor({ parallelJobs = 1, delay = 0, jobCallback }: Opts<T, R>) {
        super();
        this._jobId = 0;
        this._delay = delay;
        this._parallelJobs = parallelJobs;
        this._queuedJobs = [];
        this._activeJobs = [];
        this._jobCallback = jobCallback;
        this._allJobsPersistedEmitted = false;
    }

    get parallelJobs() {
        return this._parallelJobs;
    }

    get jobsActive() {
        return this._activeJobs.length;
    }

    get jobsQueued() {
        return this._queuedJobs.length;
    }

    async _next() {
        if (this.jobsActive < this._parallelJobs && this._queuedJobs.length > 0) {
            let job: Job<T, R> | undefined = this._queuedJobs.shift()!;

            while (job.isCancelled()) {
                job = this._queuedJobs.shift();
                if (!job) {
                    return;
                }
            }

            this._activeJobs.push(job);
            this._allJobsPersistedEmitted = false;
            if (this._delay > 0) {
                await promiseDelay(this._delay);
            }
            if (job.isCancelled()) {
                job.cancellationToken.signal();
                job.reject(new CancellationError());
            }
            try {
                const resultPromise = Promise.resolve(this._jobCallback(job, ...job.args));
                const result = await resultPromise;
                const i = this._activeJobs.indexOf(job);
                this._activeJobs.splice(i, 1);
                if (!job.isCancelled()) {
                    job.resolve(result as any);
                } else {
                    job.cancellationToken.signal();
                    job.reject(new CancellationError());
                }
            } catch (e) {
                const i = this._activeJobs.indexOf(job);
                this._activeJobs.splice(i, 1);
                if (!job.isCancelled()) {
                    job.reject(e);
                } else {
                    job.cancellationToken.signal();
                    job.reject(new CancellationError());
                }
            }
            this.emit("jobComplete", job);
            void this._next();
        }

        await promiseDelay(1000);
        if (this.jobsActive === 0 && this.jobsQueued === 0 && !this._allJobsPersistedEmitted) {
            this._allJobsPersistedEmitted = true;
            this.emit("allJobsComplete");
        }
    }

    async cancelActiveJobs() {
        const ret = [];
        for (const job of this._activeJobs) {
            ret.push(job.cancellationToken.getSignal());
            job.cancel();
        }
        await Promise.all(ret);
    }

    async cancelOldestJob() {
        if (this.jobsActive > 0) {
            const job = this._activeJobs[0]!;
            const signal = job.cancellationToken.getSignal();
            job.cancel();
            await signal;
        }
    }

    async cancelJobOfId(jobId: number) {
        for (const job of this._activeJobs) {
            if (job.id === jobId) {
                const signal = job.cancellationToken.getSignal();
                job.cancel();
                await signal;
                return;
            }
        }

        for (const job of this._queuedJobs) {
            if (job.id === jobId) {
                job.cancel();
                return;
            }
        }
    }

    postJob(...args: T): PromisedJob<T, UnwrapPromise<R>> {
        let job: Job<T, R> | undefined;

        const promise = new Promise<UnwrapPromise<R>>((resolve, reject) => {
            job = new Job<T, R>(++this._jobId, resolve, reject, args);
            this._queuedJobs.push(job);
        });
        (job as any).promise = promise;
        void this._next();
        return job as any;
    }
}


text:
<?xml version='1.0' encoding='UTF-8'?>
<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
  <!--General: Names-->
  <string name="app_name">ChatSecure</string>
  <string name="im_label">ChatSecure</string>
  <!--General: Permissions-->
  <string name="ro_perm_label">leer mensajes </string>
  <string name="ro_perm_desc">\nPermitir a las aplicaciones leer del proveedor de contenido de mensajería instantánea.\n    </string>
  <string name="wo_perm_label">escribir mensajes </string>
  <string name="wo_perm_desc">\nPermitir a las aplicaciones escribir en el proveedor de contenido de mensajería instantánea.</string>
  <string name="perm_label">iniciar servicio de MI</string>
  <string name="perm_desc">Permitir que las aplicaciones inicien el servicio de MI mediante la ejecución de un intento.</string>
  <!--General: Actions-->
  <string name="confirm">Confirmar</string>
  <string name="ok">Aceptar</string>
  <string name="cancel">Cancelar</string>
  <string name="yes">Aceptar</string>
  <string name="no">Cancelar</string>
  <string name="btn_next">Siguiente</string>
  <string name="btn_back">Atrás</string>
  <!--Views-->
  <!--Views: Setup-->
  <string name="landing_page_title">Seleccionar una cuenta</string>
  <string name="choose_account_title">Seleccionar una cuenta</string>
  <string name="add_account">Añadir cuenta <xliff:g id="ACCOUNT">%1$s</xliff:g></string>
  <string name="menu_about">Acerca de</string>
  <string name="menu_sign_out_all">Salir</string>
  <string name="signout_all_confirm_message">¿Quiere cerrar sesión en todos los servicios?</string>
  <string name="signed_out_prompt">Se ha cerrado su cuenta de <xliff:g id="ACCOUNT">%1$s</xliff:g>.</string>
  <string name="signed_out_prompt_with_error">Se ha cerrado la cuenta de <xliff:g id="ACCOUNT">%1$s</xliff:g> porque <xliff:g id="REASON">%2$s</xliff:g>.</string>
  <string name="welcome_first">¿Es la primera vez que utiliza ChatSecure?</string>
  <string name="welcome_skip">Comenzar directamente</string>
  <string name="welcome_about">Comenzar</string>
  <string name="welcome_account">Configuración de cuenta</string>
  <string name="setup_passphrase_title">Configuración de contraseña</string>
  <string name="setup_passphrase">Antes de empezar por favor, elija una contraseña segura para proteger sus datos contra el acceso ChatSecure injusto.</string>
  <string name="setup_passphrase_label1">Contraseña :</string>
  <string name="setup_passphrase_label2">Contraseña (otra vez) :</string>
  <!--Views: About: Welcome-->
  <string name="about_welcome_title">Acerca de ChatSecure</string>
  <string name="about_welcome">ChatSecure es una aplicación de mensajería instantánea que permite que nadie pueda escuchar sus conversaciones.\n\nEsta aplicación funciona con cualquier servicio de  mensajería instantánea que utilice el protocolo XMPP como Google GTalk y Jabber.org.</string>
  <!--Views: About: OTR-->
  <string name="about_otr_title">¿Es seguro?</string>
  <string name="about_otr">\'Off-the-Record Messaging\' es un protocolo seguro que proporciona privacidad de forma similar a las conversaciones del mundo real aportando cifrado, autenticación, negación y confidencialidad directa.\n\nEl protocolo OTR es compatible con clientes de escritorio como Adium y Pidgin.</string>
  <!--Views: About: Security-->
  <string name="about_security_title">¿Es seguro?</string>
  <string name="about_security">El cifrado de conversaciones en ChatSecure  solo funciona con  usuarios que utilizan una aplicación compatible. \nVerifique que sus contactos utilizan ChatSecure en su dispositivo móvil o Adium/Pidgin en su escritorio. Puede ajustar de qué manera ChatSecure intenta cifrar sus conversaciones en Configuración de la cuenta.</string>
  <!--Views: Account list-->
  <string name="menu_new_account">Nueva cuenta</string>
  <string name="menu_add_account">Añadir cuenta</string>
  <string name="menu_edit_account">Editar cuenta</string>
  <string name="menu_remove_account">Eliminar cuenta</string>
  <!--Views: Setup: Account-->
  <string name="label_username">Nombre de usuario:</string>
  <string name="label_password">Contraseña:</string>
  <string name="remember_password">Recordar </string>
  <string name="keep_me_signed_in">Iniciar sesión automáticamente.</string>
  <string name="sign_up">¿Aún no tiene una cuenta?</string>
  <string name="sign_in">Iniciar sesión</string>
  <string name="check_save_password">Por su seguridad, si pierde el teléfono o se lo roban, visite el sitio Web en su equipo y cambie su contraseña.</string>
  <string name="check_auto_sign_in">Esta opción le permite iniciar sesión automáticamente cada vez que abra la aplicación. Para desactivarla, cierre sesión y desactive la casilla de verificación \\"Acceder automáticamente\\".</string>
  <string name="use_tor">Conectar a través de Tor (Requiere la aplicación Orbot)</string>
  <string name="account_setup_example_email_address">usuario@dominio.com</string>
  <string name="account_setup_password">contraseña</string>
  <string name="account_setup_advanced_button">Configuración avanzada de la cuenta</string>
  <string name="account_select_type">Tipo de cuenta</string>
  <string name="account_setup_pers_sub">Persistencia</string>
  <string name="account_setup_pers_pw_title">Recordar contraseña</string>
  <string name="account_setup_pers_pw_on">Almacenar contraseña en caché</string>
  <string name="account_setup_pers_pw_off">No almacenar contraseña en caché</string>
  <string name="account_setup_pers_auto_title">Iniciar sesión automáticamente</string>
  <string name="account_setup_pers_auto_on">Conectar ChatSecure al iniciar</string>
  <string name="account_setup_pers_auto_off">No conectar ChatSecure al iniciar</string>
  <string name="account_setup_pers_now_title">Iniciar sesión ahora</string>
  <string name="account_setup_pers_now_on">Iniciar sesión en la cuenta siguiente</string>
  <string name="account_setup_pers_now_off">No iniciar sesión en la cuenta siguiente</string>
  <string name="account_setup_personal_sub">Personal (opcional)</string>
  <string name="account_setup_personal_alias_title">Cuenta Alias (su nombre)</string>
  <string name="account_setup_personal_alias_sub">Cómo aparece su cuenta en línea</string>
  <string name="account_setup_personal_profile_title">Perfil</string>
  <string name="account_setup_personal_profile_sub">Breve descripción del usuario</string>
  <string name="account_setup_advanced_enc_force">Forzar cifrado / rechazar texto plano</string>
  <string name="account_setup_advanced_enc_auto">Cifrar conversaciones automáticamente cuando sea posible</string>
  <string name="account_setup_advanced_enc_req">Cifrar conversaciones si se solicita</string>
  <string name="account_setup_advanced_enc_off">Inhabilitar el cifrado en las conversaciones</string>
  <string name="account_setup_signin_a">Validando credenciales …</string>
  <string name="account_setup_signin_b">Generando un par de claves …</string>
  <string name="account_setup_signin_c">Iniciando sesión…</string>
  <string name="account_wizard_setup_title">Asistente para cuenta</string>
  <string name="account_wizard_account_title">Su ID de la cuenta</string>
  <string name="account_wizard_host_title">Configurar el servidor</string>
  <string name="account_wizard_ready_title">¿Está listo?</string>
  <string name="account_wizard_setup_body">Introduzca su ID de cuenta para configurar ChatSecure utilizando XMPP. El ID es similar a una dirección de correo electrónico:</string>
  <string name="account_wizard_account_body">Por favor, introduzca su ID de cuenta (usuario @ nombre de host) :</string>
  <string name="account_wizard_host_body">Por favor, introduzca o edite el nombre del servidor y número de puerto (5222 por defecto).</string>
  <string name="account_wizard_ready_body">ChatSecure se ha configurado, ¡ahora es el momento de conectarse  y empezar a conversar de forma segura y privada!</string>
  <string name="_via_orbot">Orbot (Tor)</string>
  <string name="menu_cancel_signin">Cancelar inicio de sesión</string>
  <string name="signing_in_wait">Iniciando sesión</string>
  <!--Views: Settings: Account-->
  <string name="do_srv_lookup">Hacer búsqueda SRV</string>
  <string name="use_dns_srv_to_find_actual_xmpp_server_from_domain_name">Realizar una búsqueda SRV para encontrar el servidor XMPP a partir del nombre de dominio</string>
  <string name="allow_the_username_and_password_to_be_sent_as_plain_text_when_using_an_unencrypted_transport">Permitir que el usuario y la contraseña sean enviados en texto plano cuando no se utiliza cifrado</string>
  <string name="allow_plain_text_auth">Texto plano</string>
  <string name="verify_that_the_certificate_is_trusted">Verificar que el certificado es confiable</string>
  <string name="tls_verification">Verificación TLS</string>
  <string name="require_tls_ssl_connection">Utilizar TLS/SSL</string>
  <string name="transport_encryption">Capa de transporte</string>
  <string name="how_encrypted_chats_are_started">De qué manera comienzan las conversaciones cifradas</string>
  <string name="the_server_to_connect_to_if_needed">El servidor al que conectarse, si es necesario</string>
  <string name="connect_server">Servidor</string>
  <string name="tcp_port_for_xmpp_server">Puerto TCP del servidor XMPP</string>
  <string name="server_port">Puerto de servidor</string>
  <string name="xmpp_resource">Recurso XMPP</string>
  <string name="to_distinguish_this_connection_from_other_clients_that_are_also_logged_in">distinguir esta conexión de otros clientes que también han iniciado sesión</string>
  <string name="xmpp_resource_prio_title">Prioridad del recurso</string>
  <string name="xmpp_resource_prio_summary">Los mensajes a clientes con recursos múltiples activos serán enviados al recurso con la prioridad más alta</string>
  <!--Views: Contact list-->
  <string name="title_chats">Conversaciones</string>
  <string name="no_messages">No hay conversaciones activas.\n\n¡Pulse aquí para comenzar una!</string>
  <string name="empty_account_message">No tiene ninguna cuenta configurada.\n\n¡Pulse aquí para añadir una!</string>
  <string name="menu_add_contact">Añadir contacto</string>
  <string name="menu_remove_contact">Eliminar contacto</string>
  <string name="menu_block_contact">Bloquear contacto</string>
  <string name="menu_view_blocked">Bloqueados</string>
  <string name="confirm_delete_contact">El contacto \"<xliff:g id="USER">%1$s</xliff:g>\" se eliminará.</string>
  <string name="confirm_block_contact">El contacto \"<xliff:g id="USER">%1$s</xliff:g>\" se bloqueará.</string>
  <string name="confirm_unblock_contact">El contacto \"<xliff:g id="USER">%1$s</xliff:g>\" se desbloqueará.</string>
  <string name="add_contact_success">Contacto \"<xliff:g id="USER">%1$s</xliff:g>\" añadido</string>
  <string name="delete_contact_success">Contacto \"<xliff:g id="USER">%1$s</xliff:g>\" eliminado</string>
  <string name="block_contact_success">Contacto \"<xliff:g id="USER">%1$s</xliff:g>\" bloqueado</string>
  <string name="unblock_contact_success">Contacto \"<xliff:g id="USER">%1$s</xliff:g>\" desbloqueado</string>
  <string name="menu_new_chat">Nueva conversación</string>
  <string name="menu_search_contacts">Buscar Contactos</string>
  <string name="menu_start_chat">Iniciar conversación</string>
  <string name="menu_view_profile">Verficar</string>
  <string name="ongoing_conversation">Conversaciones en curso (<xliff:g id="NUMBER">%1$d</xliff:g>)</string>
  <string name="online_count"><xliff:g id="NUMBER">%1$d</xliff:g> conectado</string>
  <string name="subscriptions">Invitaciones de amigos</string>
  <string name="unknown_contact">(\"<i>\"Desconocido\"</i>\")</string>
  <string name="empty_contact_group">Vacío</string>
  <string name="empty_conversation_group">Ninguna conversación</string>
  <string name="search_label">Contacto</string>
  <string name="search_hint">escriba el nombre del contacto para comenzar una conversación</string>
  <string name="search_button_text">Ir</string>
  <string name="empty_chat_list">No hay ninguna conversación activa.</string>
  <string name="add_contact_title">Añadir contacto</string>
  <string name="input_contact_label">Dirección de correo electrónico de la persona a la que desea invitar:</string>
  <string name="choose_list_label">Seleccionar una lista:</string>
  <string name="invite_instruction">Escriba el nombre del contacto que quiera añadir.</string>
  <string name="invite_label">Enviar invitación</string>
  <string name="contact_profile_title">Perfil del contacto</string>
  <string name="label_status">Estado:</string>
  <string name="label_client_type">Tipo de cliente:</string>
  <string name="client_type_computer">Equipo</string>
  <string name="client_type_mobile">Móvil</string>
  <string name="blocked_list_title">Contactos bloqueados - <xliff:g id="USER">%1$s</xliff:g></string>
  <string name="no_blocked_contact">No hay ningún contacto bloqueado.</string>
  <!--Views: Chat: Single-->
  <string name="chat_with">Conversación con <xliff:g id="USER">%1$s</xliff:g></string>
  <string name="me">Yo</string>
  <string name="contact_online"><xliff:g id="USER">%1$s</xliff:g> está conectado</string>
  <string name="contact_away"><xliff:g id="USER">%1$s</xliff:g> está ausente</string>
  <string name="contact_busy"><xliff:g id="USER">%1$s</xliff:g> está ocupado</string>
  <string name="contact_offline"><xliff:g id="USER">%1$s</xliff:g> está desconectado</string>
  <string name="contact_joined"><xliff:g id="USER">%1$s</xliff:g> se ha unido a la conversación</string>
  <string name="contact_left"><xliff:g id="USER">%1$s</xliff:g> se ha desconectado</string>
  <string name="send">Enviar</string>
  <string name="compose_hint">Escriba el texto aquí</string>
  <string name="menu_resend">Reenviar</string>
  <string name="menu_end_conversation">Finalizar conversación</string>
  <string name="menu_clear_chat">Borrar Conversación</string>
  <string name="menu_insert_smiley">Insertar emoticono</string>
  <string name="menu_switch_chats">Cambiar de conversación</string>
  <string name="menu_plus">MENU+</string>
  <string name="select_link_title">Seleccionar enlace</string>
  <!--Views: Chat: Group-->
  <string name="invitation_prompt"><xliff:g id="USER">%1$s</xliff:g> le ha invitado a unirse a una conversación en grupo.</string>
  <string name="invitation_sent_prompt">Se ha enviado la invitación a <xliff:g id="USER">%1$s</xliff:g>.</string>
  <string name="accept_invitation">Aceptar</string>
  <string name="decline_invitation">Rechazar</string>
  <string name="menu_invite_contact">Invitar…</string>
  <string name="contacts_picker_title">Seleccionar contactos a los que se dirige la invitación</string>
  <string name="contact_filter_hint">Escriba el nombre del contacto que quiera localizar</string>
  <string name="empty_contact_list">No se ha encontrado ningún contacto.</string>
  <string name="approve_subscription">Sí</string>
  <string name="decline_subscription">No</string>
  <string name="approve_subscription_error">No se ha podido aprobar la suscripción de <xliff:g id="USER">%1$s</xliff:g>. Inténtelo de nuevo más tarde.</string>
  <string name="decline_subscription_error">No se ha podido rechazar la suscripción de <xliff:g id="USER">%1$s</xliff:g>. Inténtelo de nuevo más tarde.</string>
  <!--Security: OTR-->
  <string name="menu_otr_start">Iniciar cifrado</string>
  <string name="menu_otr_stop">Finalizar cifrado</string>
  <string name="starting_otr_chat">Comenzando conversación cifrada…</string>
  <string name="stopping_otr_chat">Deteniendo conversación cifrada…</string>
  <string name="label_fingerprint_remote">Sus huellas digitales</string>
  <string name="label_fingerprint_local">Su huella digital</string>
  <string name="menu_sign_in">Iniciar sesión</string>
  <string name="menu_gen_key">Regenerar clave</string>
  <string name="otr_session_status_plaintext">Advertencia: el cifrado no está activado en esta conversación</string>
  <string name="otr_session_status_encrypted">Esta conversación es segura, pero la identidad de los participantes NO ha sido verificada</string>
  <string name="otr_session_status_finished">Advertencia: el cifrado en esta conversación ha sido desactivado.</string>
  <string name="otr_session_status_verified">Esta conversación es segura y se encuentra verificada</string>
  <string name="otr_gen_key">Generando un nuevo par de claves OTR…</string>
  <!--Security: OTR: Keyring-->
  <!--Security: OTR: Verification-->
  <string name="menu_scan">Examinar huellas digitales</string>
  <string name="menu_fingerprint">Su huella digital</string>
  <string name="menu_verify_fingerprint">Verificar huella digital</string>
  <string name="menu_verify_secret">Verificar secreto</string>
  <!--Security: OTR: Verification: QA-->
  <string name="smp_question_title">Autenticación</string>
  <string name="smp_question_summary">Introduzca una pregunta para enviar a su contacto junto a la respuesta que espera recibir para verificar que se trata de la persona que dice ser.</string>
  <string name="smp_question_hint">la pregunta que formular </string>
  <string name="qmp_answer_hint">la respuesta que se espera</string>
  <string name="remote_verified_us">Su contacto le ha autenticado. Ahora valide a su contacto mediante una pregunta.</string>
  <string name="otr_qa_send">Enviar</string>
  <string name="otr_qa_cancel">Cancelar</string>
  <!--Views: VoIP-->
  <!--Views: Settings: General-->
  <string name="account_setup_title">Configuración de cuenta</string>
  <!--Actions: Settings: General: Security and Privacy-->
  <string name="pref_group_security_title">Seguridad y privacidad</string>
  <string name="encryption_and_anonymity_title">Cifrado y Anonimato</string>
  <string name="menu_view_encrypt_chat">Cifrar Encendido/Apagado</string>
  <!--Actions: Settings: General: User Interface-->
  <string name="pref_group_looknfeel_title">Interfaz de usuario</string>
  <string name="menu_locale">Idioma</string>
  <string name="KEY_PREF_LANGUAGE_TITLE">Idiomas</string>
  <string name="pref_theme_dark">Utilizar tema oscuro</string>
  <string name="pref_in_memory_db_title">Guardar conversaciones</string>
  <string name="pref_in_memory_db_summary">No almacenar los mensajes en flash para evitar que puedan ser recuperados. (Advertencia: esto puede provocar la pérdida de mensajes)</string>
  <string name="pref_background_title">Imagen de fondo</string>
  <string name="pref_background_summary">Establecer una ruta para la imagen de fondo de la aplicación</string>
  <!--Actions: Settings: General: Other Tuning-->
  <string name="pref_group_tuning_title">Otros ajustes</string>
  <string name="start_on_boot">Conectar al inicio</string>
  <string name="start_on_boot_summary">Iniciar sesión automáticamente </string>
  <string name="hide_offline_contacts">Ocultar desconectados</string>
  <string name="foreground_service_title">Prioridad primer plano</string>
  <string name="foreground_service_summary">Disminuye la probabilidad de que Android reinicie la conexión. Esto añadirá una entrada en el área de notificación</string>
  <string name="heartbeat_interval_title">Intervalo de latidos</string>
  <string name="heartbeat_interval_summary">Utilizar un valor más alto (en minutos) para ahorrar batería. Esto puede provocar que su proveedor cierre la conexión por inactividad</string>
  <!--Actions: Settings: General: Notifications-->
  <string name="notification_group_title">Configuración de notificaciones</string>
  <string name="notification_enabled_title">Notificaciones de MI</string>
  <string name="notification_enabled_summary">Notificar cuando se recibe un mensaje  instantáneo en la barra de estado </string>
  <string name="notification_vibrate_title">Vibrar</string>
  <string name="notification_vibrate_summary">Vibrar al recibir un mensaje </string>
  <string name="notification_sound_title">Sonido</string>
  <string name="notification_sound_summary">Reproducir un tono al recibir mensaje instantáneo</string>
  <string name="notification_ringtone_title">Seleccionar tono</string>
  <!--Actions: Settings: General: Developer-->
  <!--Alerts: Dialogs-->
  <string name="bg_data_prompt_title">Datos de red inhabilitados</string>
  <string name="bg_data_prompt_message">Para iniciar <xliff:g id="PROVIDER">%1$s</xliff:g>, es necesario habilitar los datos de referencia.</string>
  <string name="bg_data_prompt_ok">Habilitar</string>
  <string name="bg_data_prompt_cancel">Salir</string>
  <string name="signout_kill_confirm_message">¿Quiere cerrar sesión y acabar con todos los procesos?</string>
  <!--Alerts: Notifications-->
  <string name="newMessages_label">Mensajes nuevos de <xliff:g id="PROVIDER">%1$s</xliff:g></string>
  <string name="num_unread_chats"><xliff:g id="NUMBER">%1$d</xliff:g> conversaciones no leídas</string>
  <string name="subscription_notify_text">Invitación de amigo nuevo de <xliff:g id="USER">%s</xliff:g></string>
  <string name="notify_groupchat_label">Invitación a conversación en grupo</string>
  <string name="group_chat_invite_notify_text">Nueva invitación a conversación en grupo de <xliff:g id="USER">%s</xliff:g></string>
  <string name="new_messages_notify">Nuevo mensaje de:</string>
  <!--Alerts: Exceptions-->
  <string name="error">Atención</string>
  <string name="general_error">Código de error <xliff:g id="CODE">%1$d</xliff:g></string>
  <string name="login_service_failed">No ha sido posible acceder al servicio <xliff:g id="SERVICE">%1$s</xliff:g>. Inténtelo de nuevo más tarde."\n"(Detalles: <xliff:g id="DESCRIPTION">%2$s</xliff:g>)</string>
  <string name="add_list_failed">La lista no se ha añadido.</string>
  <string name="block_contact_failed">No se ha podido bloquear el contacto.</string>
  <string name="unblock_contact_failed">No se ha podido desbloquear el contacto.</string>
  <string name="select_contact">Seleccione primero un contacto.</string>
  <string name="disconnected">¡Desconectado!\n</string>
  <string name="service_error">¡Error del servicio!</string>
  <string name="load_contact_list_failed">No se ha podido cargar la lista de contactos.</string>
  <string name="cant_connect_to_server">No se puede establecer conexión con el servidor. Compruebe la conexión.</string>
  <string name="contact_already_exist"><xliff:g id="USER">%1$s</xliff:g> ya figura en su lista de contactos.</string>
  <string name="contact_blocked">El contacto \"<xliff:g id="USER">%1$s</xliff:g>\" se ha bloqueado.</string>
  <string name="contact_not_loaded">Por favor, espera mientras se carga la lista de contactos.</string>
  <string name="network_error">Se ha producido un error de red.</string>
  <string name="wifi_not_connected_error">Se necesita una conexión WiFi.</string>
  <string name="service_not_support">El servidor no admite esta función.</string>
  <string name="invalid_password">La contraseña introducida no es válida.</string>
  <string name="internal_server_error">Se ha producido un error en el servidor.</string>
  <string name="not_implemented">El servidor no admite esta función.</string>
  <string name="service_unavaiable">El servidor no está disponible en este momento.</string>
  <string name="timeout">Se ha agotado el tiempo de espera del servidor.</string>
  <string name="version_not_supported">El servidor no admite la versión actual.</string>
  <string name="message_queue_full">La cola de mensajes está llena.</string>
  <string name="domain_not_supported">El servidor no admite el reenvío al dominio.</string>
  <string name="unknown_user">El nombre de usuario introducido no se reconoce.</string>
  <string name="recipient_blocked_the_user">El usuario le ha bloqueado.</string>
  <string name="session_expired">La sesión ha expirado. Inicie sesión de nuevo.</string>
  <string name="forced_logout">ha iniciado sesión desde otro cliente.</string>
  <string name="already_logged_in">ha iniciado sesión desde otro cliente.</string>
  <string name="msisdn_error">No se puede leer el número de teléfono de la tarjeta SIM. Póngase en contacto con su operador para obtener ayuda.</string>
  <string name="not_signed_in">No ha iniciado sesión.</string>
  <string name="account_setup_error_validating">ChatSecure encontró un error al intentar validar su nombre de usuario o contraseña - por favor, compruebe que son correctos y vuelva a intentarlo.</string>
  <string name="account_setup_error_keypair">ChatSecure encontró un error al generar un par de claves.</string>
  <string name="account_setup_error_server">ChatSecure ha detectado un error al conectar con el servidor - por favor revise su configuración y vuelva a intentarlo.</string>
  <string name="account_setup_error_connectivity">ChatSecure encontró un error al conectar - por favor verifique su conectividad de red y vuelva a intentarlo.</string>
  <string name="error_suspended_connection">ChatSecure ha perdido la conexión a la red</string>
  <string name="error_reestablish_connection">ChatSecure está tratando de reestablecer la conexión</string>
  <string name="account_wizard_no_domain_warning">No se ha introducido un nombre de dominio en su ID de cuenta, ¡vuélvalo a intentar! </string>
  <string name="account_wizard_no_root_domain_warning">Su nombre de host no contiene un .com, .net u otro valor, ¡vuélvalo a intentar! </string>
  <string name="signin_password_prompt">Introduzca su contraseña:</string>
  <string name="warning_tor_connect">Dado que está utilizando Tor, debe introducir el nombre de host del servidor XMPP en Configuración avanzada de la cuenta</string>
  <string name="msg_sent_failed">No se ha podido enviar el mensaje.</string>
  <string name="disconnected_warning">Se ha perdido la conexión con el servidor. Los mensajes se enviarán cuando se restablezca la conexión.</string>
  <string name="contact_offline_warning"><xliff:g id="USER_0">%1$s</xliff:g> está desconectado. Los mensajes enviados se entregarán cuando <xliff:g id="USER_1">%1$s</xliff:g> vuelva a conectarse.</string>
  <string name="contact_not_in_list_warning"><xliff:g id="USER">%1$s</xliff:g> no figura en tu lista de contactos.</string>
  <string name="account_settings_title">Configuración de la cuenta</string>

  <string name="warning_alpha">ADVERTENCIA: Esta es una versión anticipada de ChatSecure que puede contener vulnerabilidades de seguridad o errores.</string>
  <!--added 2011/09/01-->
  <string name="menu_view_groups">Grupos</string>
  <string name="_open_conversations">conversaciones abiertas</string>
  <string name="menu_exit">Salir</string>
  <!--Other-->
  <!--Other: Slide Menu-->
  <string name="menu_contact_list">Lista de contactos</string>
  <string name="menu_settings">Ajustes</string>
  <string name="menu_view_accounts">Lista de cuentas</string>
  <string name="menu_sign_out">Cerrar sesión</string>
  <string name="menu_view_contact_list">Lista de contactos</string>
  <!--Other: Provider-->
  <string name="provider_full_name_xmpp">Jabber (XMPP)</string>
  <string name="provider_full_name_llxmpp">Sesión de chat en red local  (Bonjour/ZeroConf)</string>
  <string name="google_account">Cuenta de Google</string>
  <!--Other: Development Strings [Do not localize!]-->
  <!--Other: Presence States-->
  <string name="presence_available">Conectado</string>
  <string name="presence_busy">Ocupado</string>
  <string name="presence_away">Ausente</string>
  <string name="presence_idle">Inactivo</string>
  <string name="presence_offline">Desconectado</string>
  <string name="presence_invisible">Aparecer desconectado</string>
  <!--Other: Smileys-->
  <string-array name="default_smiley_names">
    <item>Feliz</item>
    <item>Triste</item>
    <item>Parpadeo</item>
    <item>Lengua fuera</item>
    <item>Sorprendido</item>
    <item>Besos</item>
    <item>Gritar</item>
    <item>Fresco</item>
    <item>Dinero boca</item>
    <item>Los pies en la boca</item>
    <item>Avergonzado</item>
    <item>Angel</item>
    <item>Indeciso</item>
    <item>Llorar</item>
    <item>Los labios están sellados</item>
    <item>Riendo</item>
    <item>Confundido</item>
  </string-array>
  <!--[Do not localize!]-->
  <string-array name="smiley_names">
    <item>Feliz</item>
    <item>Triste</item>
    <item>Parpadeo</item>
    <item>Lengua fuera</item>
    <item>Sorprendido</item>
    <item>Besos</item>
    <item>Gritar</item>
    <item>Fresco</item>
    <item>Dinero boca</item>
    <item>Los pies en la boca</item>
    <item>Avergonzado</item>
    <item>Angel</item>
    <item>Indeciso</item>
    <item>Llorar</item>
    <item>Los labios están sellados</item>
    <item>Riendo</item>
    <item>Confundido</item>
  </string-array>
  <string-array name="smiley_texts">
    <item>:-)</item>
    <item>:-(</item>
    <item>;-)</item>
    <item>:-P</item>
    <item>=-O</item>
    <item>:-*</item>
    <item>:O</item>
    <item>B-)</item>
    <item>:-$</item>
    <item>:-!</item>
    <item>:-[</item>
    <item>O:-)</item>
    <item>:-\\</item>
    <item>:\'(</item>
    <item>:-X</item>
    <item>:-D</item>
    <item>o_O</item>
  </string-array>
  <string name="i_need_a_new_account">Nueva cuenta</string>
</resources>


text:
from django.core.management.base import NoArgsCommand
from spa.models import Mix

class Command(NoArgsCommand):
    def handle_noargs(self, **options):
        try:
            #l = Mix.objects.filter(slug='dss-on-deepvibes-radio-17th-july-jamie-o-sullivan')[0]
            l = Mix.objects.filter(favourites__slug='fergalmoran')[0]
            for fav in l.favourites.all():
                print fav.slug
            pass
        except Exception, ex:
            print "Debug exception: %s" % ex.message


text:
@interface DDCometSubscription : NSObject

@property (nonatomic, copy, readonly) NSString *channel;
@property (nonatomic, unsafe_unretained, readonly) id target;
@property (nonatomic, readonly) SEL selector;

- (id)initWithChannel:(NSString *)channel target:(id)target selector:(SEL)selector;
- (BOOL)matchesChannel:(NSString *)channel;

@end


text:
using System;
using System.IO;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using UnityEditor.Callbacks;

using Bonsai.Utility;

namespace UNEB
{
    /// <summary>
    /// Handles the saving and loading of tree assets.
    /// </summary>
    public class SaveManager
    {
        public enum SaveState { NoGraph, TempGraph, SavedGraph };

        // The FSM used to structure the logic control of saving and loading.
        private StateMachine<SaveState> _saveFSM;

        // The events that dictate the flow of the manager's FSM.
        private enum SaveOp { None, New, Load, Save, SaveAs };
        private SaveOp _saveOp = SaveOp.None;

        private NodeEditorWindow _window;

        private const string kRootUNEB = "UNEB";

        // Path that stores temporary graphs.
        private const string kTempGraphDirectory = "TempGraphsUNEB";
        private const string kTempFileName = "TempNodeGraphUNEB";

        public SaveManager(NodeEditorWindow w)
        {
            _window = w;

            _saveFSM = new StateMachine<SaveState>();

            var noGraph = new StateMachine<SaveState>.State(SaveState.NoGraph);
            var tempGraph = new StateMachine<SaveState>.State(SaveState.TempGraph);
            var savedGraph = new StateMachine<SaveState>.State(SaveState.SavedGraph);

            _saveFSM.AddState(noGraph);
            _saveFSM.AddState(tempGraph);
            _saveFSM.AddState(savedGraph);

            // Actions to take when starting out on a window with no graph.
            _saveFSM.AddTransition(noGraph, tempGraph, isNewRequested, createNewOnto_Window_WithTempOrEmpty);
            _saveFSM.AddTransition(noGraph, savedGraph, isLoadRequested, loadOnto_EmptyWindow);

            // Actions to take when the window has a temp graph.
            _saveFSM.AddTransition(tempGraph, tempGraph, isNewRequested, createNewOnto_Window_WithTempOrEmpty);
            _saveFSM.AddTransition(tempGraph, savedGraph, isSaveOrSaveAsRequested, saveTempAs);
            _saveFSM.AddTransition(tempGraph, savedGraph, isLoadRequested, loadOnto_Window_WithTempgraph);

            // Actions to take when the window has a valid graph (already saved).
            _saveFSM.AddTransition(savedGraph, savedGraph, isSaveRequested, save);
            _saveFSM.AddTransition(savedGraph, savedGraph, isSaveAsRequested, saveCloneAs);
            _saveFSM.AddTransition(savedGraph, savedGraph, isLoadRequested, loadOnto_Window_WithSavedgraph);
            _saveFSM.AddTransition(savedGraph, tempGraph, isNewRequested, createNewOnto_Window_WithSavedgraph);

            // Consume the save operation even after the transition is made.
            _saveFSM.OnStateChangedEvent += () => { _saveOp = SaveOp.None; };

            InitState();

            NodeConnection.OnConnectionCreated -= saveConnection;
            NodeConnection.OnConnectionCreated += saveConnection;
        }

        /// <summary>
        /// This hanldes setting up the proper state based on the window's graph.
        /// </summary>
        internal void InitState()
        {
            // If the window has a valid graph and editable.
            if (_window.graph != null && _window.GetMode() == NodeEditorWindow.Mode.Edit) {

                string path = getCurrentGraphPath();

                // If the graph is temp.
                if (path.Contains(kTempGraphDirectory)) {
                    SetState(SaveState.TempGraph);
                }

                // If the graph is saved (not a temp).
                else {
                    SetState(SaveState.SavedGraph);
                }
            }

            // Window is fresh, no graph yet set.
            else {
                SetState(SaveState.NoGraph);
            }
        }

        /// <summary>
        /// Get the path from open file dialog.
        /// </summary>
        /// <returns></returns>
        private string getGraphFilePath()
        {
            string path = EditorUtility.OpenFilePanel("Open Node Graph", "Assets/", "asset");

            // If the path is outside the project's asset folder.
            if (!path.Contains(Application.dataPath)) {

                // If the selection was not cancelled...
                if (!string.IsNullOrEmpty(path)) {
                    _window.ShowNotification(new GUIContent("Please select a Graph asset within the project's Asset folder."));
                    return null;
                }
            }

            return path;
        }

        /// <summary>
        /// Assumes that the path is already valid.
        /// </summary>
        /// <param name="path"></param>
        private void loadGraph(string path)
        {
            int assetIndex = path.IndexOf("/Assets/");
            path = path.Substring(assetIndex + 1);

            var graph = AssetDatabase.LoadAssetAtPath<NodeGraph>(path);
            _window.SetGraph(graph);
        }

        /// <summary>
        /// Gets the file path to save the canavs at.
        /// </summary>
        /// <returns></returns>
        private string getSaveFilePath()
        {
            string path = EditorUtility.SaveFilePanelInProject("Save Node Graph", "NewNodeGraph", "asset", "Select a destination to save the graph.");

            if (string.IsNullOrEmpty(path)) {
                return "";
            }

            return path;
        }

        #region Save Operations

        /// <summary>
        /// Creates and adds a node to the graph.
        /// </summary>
        /// <param name="t"></param>
        /// <param name="bt"></param>
        /// <returns></returns>
        public static Node CreateNode(Type t, NodeGraph g)
        {
            try {

                var node = ScriptableObject.CreateInstance(t) as Node;
                AssetDatabase.AddObjectToAsset(node, g);

                // Optional, set reference to graph: node.graph = g

                node.Init();
                g.Add(node);
                return node;
            }

            catch (Exception e) {
                throw new UnityException(e.Message);
            }
        }

        /// <summary>
        /// Creates and adds a node to the graph.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="bt"></param>
        /// <returns></returns>
        public static Node CreateNode<T>(NodeGraph g) where T : Node
        {
            var node = ScriptableObject.CreateInstance<T>();
            AssetDatabase.AddObjectToAsset(node, g);

            // Optional, set reference to graph: node.graph = g

            node.Init();
            g.Add(node);
            return node;
        }

        /// <summary>
        /// Creates a graph asset and saves it.
        /// </summary>
        /// <param name="path">The full path including name and extension.</param>
        /// <returns></returns>
        public static NodeGraph CreateNodeGraph(string path)
        {
            // We create a graph asset in the data base in order to add node assets
            // under the graph. This way things are organized in the editor.
            //
            // The drawback is that we need to create a temp asset for the tree
            // and make sure it does not linger if the temp asset is discarded.
            //
            // This means that we need to have a persistent directoy to store temp
            // assets.

            var graph = ScriptableObject.CreateInstance<NodeGraph>();

            AssetDatabase.CreateAsset(graph, path);
            AssetDatabase.SaveAssets();
            AssetDatabase.Refresh();

            return graph;
        }

        /// <summary>
        /// Creates a new temporary node graph.
        /// </summary>
        /// <returns></returns>
        private NodeGraph createNew()
        {
            string tempPath = getTempFilePath();

            if (!string.IsNullOrEmpty(tempPath)) {

                _window.ShowNotification(new GUIContent("New Graph Created"));
                return CreateNodeGraph(tempPath);
            }

            return null;
        }

        // Create a new temp graph on an empty window or with a temp graph.
        private bool createNewOnto_Window_WithTempOrEmpty()
        {
            _window.SetGraph(createNew());
            return true;
        }

        // Saves the current active graph then loads a new graph.
        private bool createNewOnto_Window_WithSavedgraph()
        {
            // Save the old graph to avoid loss.
            AssetDatabase.SaveAssets();

            _window.SetGraph(createNew());

            return true;
        }

        // Load a graph to a window that has no graph active.
        private bool loadOnto_EmptyWindow()
        {
            loadGraph(getGraphFilePath());
            return true;
        }

        // Load a graph to a window that has a temp graph active.
        private bool loadOnto_Window_WithTempgraph()
        {
            string path = getGraphFilePath();

            if (!string.IsNullOrEmpty(path)) {

                // Get rid of the temporary graph.
                AssetDatabase.DeleteAsset(getCurrentGraphPath());
                loadGraph(path);
                return true;
            }

            return false;
        }

        // Load a graph to a window that has a saved graph active.
        private bool loadOnto_Window_WithSavedgraph()
        {
            string path = getGraphFilePath();

            if (!string.IsNullOrEmpty(path)) {

                // Save the old graph.
                save();
                loadGraph(path);
                return true;
            }

            return false;
        }

        // Makes the temporary graph into a saved graph.
        private bool saveTempAs()
        {
            string newPath = getSaveFilePath();
            string currentPath = getCurrentGraphPath();

            //If asset exists on path, delete it first.
            if (AssetDatabase.LoadAssetAtPath<ScriptableObject>(newPath) != null) {
                AssetDatabase.DeleteAsset(newPath);
            }

            string result = AssetDatabase.ValidateMoveAsset(currentPath, newPath);

            if (result.Length == 0) {
                AssetDatabase.MoveAsset(currentPath, newPath);
                save();
                return true;
            }

            else {
                Debug.LogError(result);
                return false;
            }
        }

        // Copies the current active graph to a new location.
        private bool saveCloneAs()
        {
            string newPath = getSaveFilePath();

            if (!string.IsNullOrEmpty(newPath)) {

                string currentPath = getCurrentGraphPath();

                AssetDatabase.CopyAsset(currentPath, newPath);
                AssetDatabase.SetMainObject(_window.graph, currentPath);

                save();
                return true;
            }

            return false;
        }

        // Saves the current graph (not a temp graph).
        private bool save()
        {
            _window.graph.OnSave();
            AssetDatabase.SaveAssets();
            AssetDatabase.Refresh();

            _window.ShowNotification(new GUIContent("Graph Saved"));
            return true;
        }

        // Helper method for the NodeConnection.OnConnectionCreated callback.
        private void saveConnection(NodeConnection conn)
        {
            if (!AssetDatabase.Contains(conn)) {
                AssetDatabase.AddObjectToAsset(conn, _window.graph);
            }
        }

        #endregion

        /// <summary>
        /// Handles deleting temporary graph or saving valid graph.
        /// </summary>
        internal void Cleanup()
        {
            // Only save/delete things if we are in edit mode.
            if (_window.GetMode() != NodeEditorWindow.Mode.Edit) {
                return;
            }

            SaveState state = _saveFSM.CurrentState.Value;

            if (state == SaveState.TempGraph) {
                AssetDatabase.DeleteAsset(getCurrentGraphPath());
            }

            else if (state == SaveState.SavedGraph) {
                save();
            }
        }

        /*
         * These are conditions used the save FSM to know when to transition.
         *  */
        private bool isNewRequested() { return _saveOp == SaveOp.New; }
        private bool isLoadRequested() { return _saveOp == SaveOp.Load; }
        private bool isSaveRequested() { return _saveOp == SaveOp.Save; }
        private bool isSaveAsRequested() { return _saveOp == SaveOp.SaveAs; }
        private bool isSaveOrSaveAsRequested() { return isSaveAsRequested() || isSaveRequested(); }

        /*
         * These are the events that drive the save manager.
         * Whenever one of this is fired, the save operation is set
         * and the save FSM updated.
         * */
        internal void RequestNew() { _saveOp = SaveOp.New; _saveFSM.Update(); }
        internal void RequestLoad() { _saveOp = SaveOp.Load; _saveFSM.Update(); }
        internal void RequestSave() { _saveOp = SaveOp.Save; _saveFSM.Update(); }
        internal void RequestSaveAs() { _saveOp = SaveOp.SaveAs; _saveFSM.Update(); }

        private string getTempFilePath()
        {
            string tempRoot = getTempDirPath();

            if (string.IsNullOrEmpty(tempRoot)) {
                return "";
            }

            string filename = kTempFileName + _window.GetInstanceID().ToString().Ext("asset");
            return tempRoot.Dir(filename);
        }

        internal void SetState(SaveState state)
        {
            _saveFSM.SetCurrentState(state);
        }

        internal bool IsInNographState()
        {
            return _saveFSM.CurrentState.Value == SaveState.NoGraph;
        }

        internal SaveState CurrentState()
        {
            return _saveFSM.CurrentState.Value;
        }

        private string getCurrentGraphPath()
        {
            return AssetDatabase.GetAssetPath(_window.graph);
        }

        private string getTempDirPath()
        {
            string[] dirs = Directory.GetDirectories(Application.dataPath, kTempGraphDirectory, SearchOption.AllDirectories);

            // Return first occurance containing targetFolderName.
            if (dirs.Length != 0) {
                return getTempPathRelativeToAssets(dirs[0]);
            }

            // Could not find anything. Make the folder
            string rootPath = getPathToRootUNEB();

            if (!string.IsNullOrEmpty(rootPath)) {
                var dirInfo = Directory.CreateDirectory(rootPath.Dir(kTempGraphDirectory));
                return getTempPathRelativeToAssets(dirInfo.FullName);
            }

            else {
                return "";
            }
        }

        private static string getPathToRootUNEB()
        {
            // Find the UNEB project root directory within the Unity project.
            var dirs = Directory.GetDirectories(Application.dataPath, kRootUNEB, SearchOption.AllDirectories);

            if (dirs.Length != 0) {
                return dirs[0];
            }
            else {
                Debug.LogError("Could not find project root: /" + kRootUNEB + '/');
                return "";
            }
        }

        // Assumes that the fullTempPath is valid.
        private static string getTempPathRelativeToAssets(string fullTempPath)
        {
            int index = fullTempPath.IndexOf("Assets");
            return fullTempPath.Substring(index);
        }
    }
}