text:
package com.fab.model.filter;

import com.foc.desc.FocObject;
import com.foc.gui.FGFormulaEditorPanel;
import com.foc.gui.FPanel;
import com.foc.gui.FValidationPanel;

@SuppressWarnings("serial")
public class FilterFieldDefinitionGuiDetailsPanel extends FPanel {

	public FilterFieldDefinitionGuiDetailsPanel(FocObject focObject, int viewID){
		super("Filter field", FPanel.FILL_NONE);
		if(focObject != null){
			FilterFieldDefinition fieldFieldDef = (FilterFieldDefinition) focObject;
			FGFormulaEditorPanel comp = (FGFormulaEditorPanel) focObject.getGuiComponent(FilterFieldDefinitionDesc.FLD_CONDITION_PROPERTY_PATH);
			comp.setOriginDesc(fieldFieldDef.getFilterDefinition().getBaseFocDesc());
			add(comp, 0, 0);

			FValidationPanel validPanel = showValidationPanel(true);
			validPanel.setValidationType(FValidationPanel.VALIDATION_OK);
		}
	}
}

redpajama_set_name: RedPajamaGithub


text:
<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=UTF-8"/>
<TITLE>Additional Terms</TITLE>

Términos y condiciones de las funciones adicionales

Al pulsar el botón "I agree", el Licenciatario acepta que
el código del programa, muestras, actualizaciones,
correcciones y materiales relacionados, sujetos a licencia, tales como
claves o documentación ("Código") que está a punto de descargar se
sometan a los términos del acuerdo de licencia que el Licenciatario
aceptara cuando adquirió el Programa para el que obtiene el Código.
El Licenciatario también acepta instalar o utilizar el Código
únicamente como parte de un Programa para el cual haya adquirido un
Documento de Titularidad válido. Los términos "Programa" y "Documento
de Titularidad" tienen el mismo significado que en el Acuerdo
Internacional de Programas bajo Licencia de IBM ("IPLA"). El IPLA se
puede consultar en http://www.ibm.com/software/sla/


text:
package card_delete;

import com.balancedpayments.*;
import com.balancedpayments.errors.*;
import java.util.HashMap;
import java.util.Map;

public class card_delete {

public static void main(String[] args) throws HTTPError, NoResultsFound, MultipleResultsFound {
Balanced.configure("ak-test-2eKlj1ZDfAcZSARMf3NMhBHywDej0avSY");

Card card = new Card("/cards/CC4zyuNpxY0A0eAf87SeULCR");
try {
    card.unstore();
}
catch (HTTPError e) {}
catch (NotCreated e) {}

}
}


text:
#pragma once

/* Previously, this file was included to get access to defining a console
 * command. This logic has been moved into the following header, which is
 * what in almost every case what regular code wants to include instead of
 * this file.
 */
#include <lk/console_cmd.h>
#include <lib/console/cmd.h>

/* external api */
void console_start(void);
int console_run_script(const char *string);
int console_run_script_locked(const char *string); // special case from inside a command
console_cmd_func console_get_command_handler(const char *command);
void console_abort_script(void);

/* panic shell api */
void panic_shell_start(void);

extern int lastresult;

/* enable the panic shell if we're being built */
#if !defined(ENABLE_PANIC_SHELL) && PLATFORM_SUPPORTS_PANIC_SHELL
#define ENABLE_PANIC_SHELL 1
#endif


text:
package com.lothrazar.samsapples;
import java.util.ArrayList;
import java.util.List;
import net.minecraftforge.fml.common.registry.GameRegistry;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Items;
import net.minecraft.item.EnumRarity;
import net.minecraft.item.ItemFood;
import net.minecraft.item.ItemStack;
import net.minecraft.potion.Potion;
import net.minecraft.potion.PotionEffect;
import net.minecraft.util.text.translation.I18n;
import net.minecraft.world.World;

public class ItemFoodAppleMagic extends ItemFood {
  private boolean hasEffect = false;
  private ArrayList<Potion> potionIds;
  private ArrayList<Integer> potionDurations;
  private ArrayList<Integer> potionAmplifiers;
  public ItemFoodAppleMagic(int fillsHunger, boolean has_effect) {
    super(fillsHunger, false);//is not edible by wolf
    hasEffect = has_effect;//true gives it enchantment shine
    this.setAlwaysEdible(); //can eat even if full hunger
    this.setCreativeTab(ModApples.tabSamsContent);
    potionIds = new ArrayList<Potion>();
    potionDurations = new ArrayList<Integer>();
    potionAmplifiers = new ArrayList<Integer>();
  }
  public ItemFoodAppleMagic addEffect(Potion potionId, int potionDuration, int potionAmplifier) {
    int TICKS_PER_SEC = 20;
    potionIds.add(potionId);
    potionDurations.add(potionDuration * TICKS_PER_SEC);
    potionAmplifiers.add(potionAmplifier);
    return this;//to chain together
  }
  @Override
  protected void onFoodEaten(ItemStack par1ItemStack, World world, EntityPlayer player) {
    addAllEffects(world, player);
  }
  @Override
  public boolean hasEffect(ItemStack par1ItemStack) {
    return hasEffect; //give it shimmer, depending on if this was set in constructor
  }
  @Override
  @SideOnly(Side.CLIENT)
  public EnumRarity getRarity(ItemStack par1ItemStack) {
    if (hasEffect)
      return EnumRarity.EPIC; //dynamic text to match the two apple colours
    else
      return EnumRarity.RARE;
  }
  final static int smeltexp = 0;
  public static void addRecipe(ItemFoodAppleMagic apple, ItemStack ingredient, boolean isExpensive) {
    int refund = 8;
    if (isExpensive) {
      GameRegistry.addRecipe(new ItemStack(apple), "lll", "lal", "lll", 'l', ingredient, 'a', Items.APPLE);
    }
    else {
      GameRegistry.addShapelessRecipe(new ItemStack(apple), ingredient, Items.APPLE);
      refund = 1;
    }
    GameRegistry.addSmelting(apple, new ItemStack(ingredient.getItem(), refund, ingredient.getMetadata()), smeltexp);
  }
  @Override
  public void addInformation(ItemStack held, EntityPlayer player, List<String> list, boolean par4) {
    Potion p;
    for (int i = 0; i < potionIds.size(); i++) {
      p = potionIds.get(i);//Potion.potionTypes[potionIds.get(i)];
      list.add(I18n.translateToLocal(p.getName()));
    }
  }
  public void addAllEffects(World world, EntityLivingBase player) {
    if (world.isRemote == false) //false means serverside
      for (int i = 0; i < potionIds.size(); i++) {
        addOrMergePotionEffect(player, new PotionEffect(
            potionIds.get(i), potionDurations.get(i), potionAmplifiers.get(i)));
      }
  }
  public static void addOrMergePotionEffect(EntityLivingBase player, PotionEffect newp) {
    if (player.isPotionActive(newp.getPotion())) {
      //do not use built in 'combine' function, just add up duration myself
      PotionEffect p = player.getActivePotionEffect(newp.getPotion());
      int ampMax = Math.max(p.getAmplifier(), newp.getAmplifier());
      player.addPotionEffect(new PotionEffect(newp.getPotion(), newp.getDuration() + p.getDuration(), ampMax));
    }
    else {
      player.addPotionEffect(newp);
    }
  }
}


text:
package org.apache.wicket.jmx;

import java.io.IOException;

import org.apache.wicket.protocol.http.WebApplication;

/**
 * Exposes {@link org.apache.wicket.protocol.http.RequestLogger} for JMX.
 *
 * @author eelcohillenius
 */
public class RequestLogger implements RequestLoggerMBean
{
	private final org.apache.wicket.Application application;

	private final WebApplication webApplication;

	/**
	 * Construct.
	 *
	 * @param application
	 *            The application
	 */
	public RequestLogger(final org.apache.wicket.Application application)
	{
		this.application = application;

		// do this so that we don't have to cast all the time
		if (application instanceof WebApplication)
		{
			webApplication = (WebApplication)application;
		}
		else
		{
			webApplication = null;
		}
	}

	/**
	 * @see org.apache.wicket.jmx.RequestLoggerMBean#getNumberOfCreatedSessions()
	 */
	@Override
	public Integer getNumberOfCreatedSessions() throws IOException
	{
		org.apache.wicket.protocol.http.IRequestLogger logger = getRequestLogger();
		if (logger != null)
		{
			return logger.getTotalCreatedSessions();
		}
		return null;
	}

	/**
	 * @see org.apache.wicket.jmx.RequestLoggerMBean#getNumberOfLiveSessions()
	 */
	@Override
	public Integer getNumberOfLiveSessions() throws IOException
	{
		org.apache.wicket.protocol.http.IRequestLogger logger = getRequestLogger();
		if (logger != null)
		{
			return logger.getLiveSessions().length;
		}
		return null;
	}

	/**
	 * @see org.apache.wicket.jmx.RequestLoggerMBean#getPeakNumberOfSessions()
	 */
	@Override
	public Integer getPeakNumberOfSessions() throws IOException
	{
		org.apache.wicket.protocol.http.IRequestLogger logger = getRequestLogger();
		if (logger != null)
		{
			return logger.getPeakSessions();
		}
		return null;
	}

	/**
	 * @see org.apache.wicket.jmx.RequestLoggerMBean#getNumberOfCurrentActiveRequests()
	 */
	@Override
	public Integer getNumberOfCurrentActiveRequests() throws IOException
	{
		org.apache.wicket.protocol.http.IRequestLogger logger = getRequestLogger();
		if (logger != null)
		{
			return Integer.valueOf(logger.getCurrentActiveRequestCount());
		}
		return null;
	}

	/**
	 * @see org.apache.wicket.jmx.RequestLoggerMBean#getPeakNumberOfActiveRequests()
	 */
	@Override
	public Integer getPeakNumberOfActiveRequests() throws IOException
	{
		org.apache.wicket.protocol.http.IRequestLogger logger = getRequestLogger();
		if (logger != null)
		{
			return Integer.valueOf(logger.getPeakActiveRequestCount());
		}
		return null;
	}

	/**
	 * @see org.apache.wicket.jmx.RequestLoggerMBean#restart()
	 */
	@Override
	public void restart() throws IOException
	{
		if (webApplication != null)
		{
			webApplication.getRequestLoggerSettings().setRequestLoggerEnabled(false);
			webApplication.getRequestLogger();
			webApplication.getRequestLoggerSettings().setRequestLoggerEnabled(true);
		}
	}

	/**
	 * @see org.apache.wicket.jmx.RequestLoggerMBean#stop()
	 */
	@Override
	public void stop() throws IOException
	{
		if (webApplication != null)
		{
			webApplication.getRequestLoggerSettings().setRequestLoggerEnabled(false);
		}
	}

	/**
	 * Gets the request logger for this application.
	 *
	 * @return The request logger or null if no request is active, or if this is not a web
	 *         application
	 */
	protected org.apache.wicket.protocol.http.IRequestLogger getRequestLogger()
	{
		if (application instanceof WebApplication)
		{
			return application.getRequestLogger();
		}
		return null;
	}
}


text:
namespace content {
namespace {

SurfaceTextureManager* g_instance = NULL;

}  // namespace

// static
SurfaceTextureManager* SurfaceTextureManager::GetInstance() {
  DCHECK(g_instance);
  return g_instance;
}

// static
void SurfaceTextureManager::SetInstance(SurfaceTextureManager* instance) {
  DCHECK(!g_instance || !instance);
  g_instance = instance;
}

}  // namespace content


text: A wishlist application


text:
import { ng } from '../../utils/process';
import { expectFileToMatch, expectFileToExist } from '../../utils/fs';
import { expectToFail } from '../../utils/utils';

export default function () {
  // TODO(architect): Delete this test. It is now in devkit/build-angular.

  return ng('build', '--aot', '--build-optimizer')
    .then(() => expectToFail(() => expectFileToMatch('dist/test-project/main.js', /\.decorators =/)))
    .then(() => ng('build'))
    .then(() => expectToFail(() => expectFileToExist('dist/vendor.js')))
    .then(() => expectToFail(() => expectFileToMatch('dist/test-project/main.js', /\.decorators =/)))
    .then(() => expectToFail(() => ng('build', '--aot=false', '--build-optimizer')));
}


text:
DATAFOLDER = 'data'

# Raw data from the spider (must be located in DATAFOLDER)
RAW_DATA_FILENAME = 'big_run_2_102147.json'

# Folder where the zipcode geojson file is located (inside the DATAFOLDER)
ZIPCODE_FOLDER = 'NLPostcodes4PP'

# Input zipcode geojson file (is used by the function convert_zipcode_areas)
# This file can be created from a kml file with the kml2geojson function in the geoconversion folder
ZIPCODE_GEOJSON = 'NLPostcodes4PP.geojson'

# Output zipcode geojson file with the coordinates in web mercator format
ZIPCODE_GEOJSON_WM = 'NLPostcodes4PP_WM.geojson'

# Output geojson filename
GEOJSON_FILENAME = 'properties.geojson'

# output zipcode filename (json format)
ZIPCODE_FILENAME = 'zipcode.json'

# output folder, to store the generated plots
OUTPUT_FOLDER = 'output'


text:
/**
 * Track Overall Performance
 * This event triggers when the player has changed sources, has ended, or
 * has been destroyed.
 *
 * Example Usage:
 * player.eventTracking({
 *  performance: function(data) {
 *    // tracking here...
 *  },
 * });
 *
 * Data Attributes:
 * => pauseCount:       Total number of Pause events triggered
 * => seekCount:        Total number of Seek events triggered
 * => bufferCount:      Total number of Buffer events triggered
 * => totalDuration:    Total duration provided by the file
 * => watchedDuration:  Total number of seconds watched (not seeked past)
 * => bufferDuration:   Total seconds that buffering has occured
 * => initialLoadTime:  Seconds it took for the initial frame to appear
 *
 * @function PerformanceTracking
 * @param    {Object} [config={}]
 *           An object of config left to the plugin author to define.
 */
const PerformanceTracking = function(config) {
  if (typeof config === 'undefined' || typeof config.performance !== 'function') {
    return;
  }

  const player = this;
  let seekCount = 0;
  let pauseCount = 0;
  let bufferCount = 0;
  let totalDuration = 0;
  let watchedDuration = 0;
  let bufferDuration = 0;
  let initialLoadTime = 0;
  let timestamps = [];

  const reset = function() {
    seekCount = 0;
    pauseCount = 0;
    bufferCount = 0;
    totalDuration = 0;
    watchedDuration = 0;
    bufferDuration = 0;
    initialLoadTime = 0;
    timestamps = [];
  };

  const trigger = function() {
    const data = {
      pauseCount,
      seekCount,
      bufferCount,
      totalDuration,
      watchedDuration,
      bufferDuration,
      initialLoadTime
    };

    config.performance.call(player, data);
  };

  const triggerAndReset = function() {
    trigger();
    reset();
  };

  if (typeof window.addEventListener === 'function') {
    window.addEventListener('beforeunload', triggerAndReset);
    player.on('dispose', function() {
      window.removeEventListener('beforeunload', triggerAndReset);
    });
  }

  player.on('loadstart', function() {
    if (totalDuration > 0) {
      trigger();
    }

    reset();
  });

  player.on('ended', triggerAndReset);
  player.on('dispose', triggerAndReset);
  player.on('timeupdate', function() {
    const curTime = +player.currentTime().toFixed(0);

    if (timestamps.indexOf(curTime) < 0) {
      timestamps.push(curTime);
    }
    watchedDuration = timestamps.length;
  });
  player.on('loadeddata', function(e, data) {
    totalDuration = +player.duration().toFixed(0);
  });
  player.on('tracking:seek', function(e, data) {
    seekCount = data.seekCount;
  });
  player.on('tracking:pause', function(e, data) {
    pauseCount = data.pauseCount;
  });
  player.on('tracking:buffered', function(e, data) {
    ({ bufferCount } = data);
    bufferDuration = +(bufferDuration + data.secondsToLoad).toFixed(3);
  });
  player.on('tracking:firstplay', function(e, data) {
    initialLoadTime = data.secondsToLoad;
  });
};

export default PerformanceTracking;


text:
import { browser, element, by, $ } from 'protractor';

describe('Generate QR code', () => {

    const username = element(by.id('username'));
    const password = element(by.id('password'));
    const projectMenu = element(by.id('projects-menu'));
    const accountMenu = element(by.id('account-menu'));
    const login = element(by.id('login'));
    const logout = element(by.id('logout'));

    beforeAll(() => {
        browser.get('#');

        accountMenu.click();
        login.click();

        username.sendKeys('admin');
        password.sendKeys('admin');
        element(by.css('button[type=submit]')).click();
        browser.waitForAngular();
    });

    it('should load project view', function () {
        projectMenu.click();
        element.all(by.partialLinkText('radar')).first().click().then(() => {
            expect(element(by.className('status-header')).getText()).toMatch('RADAR');
            // expect 3 subjects in this table
            element.all(by.css('jhi-subjects tbody tr')).count().then(function(count) {
                expect(count).toEqual(3);
            });
        });
    });

    it('should open pair app dialog', function () {
        element.all(by.buttonText('Pair App')).first().click().then(() => {
            expect(element.all(by.name('pairForm')).all(by.css('h4')).first().getAttribute('jhitranslate'))
                .toMatch('managementPortalApp.subject.home.pairAppLabel');
        });
    });

    it('should be able to create a qr code', function () {
        element(by.name('pairForm')).element(by.cssContainingText('option', 'pRMT')).click().then(() => {
            element.all(by.css('qr-code')).count().then(function(count) {
                expect(count).toBe(1);
            });
            element(by.css('button.close')).click();
        });
    });

    afterAll(function () {
        accountMenu.click();
        logout.click();
    });
});


text:
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Linq;

using Windows.Web.Http;
using Windows.Web.Http.Filters;

namespace AppStudio.DataProviders.Core
{
    internal static class HttpRequest
    {

        internal static async Task<HttpRequestResult<TSchema>> ExecuteGetAsync<TSchema>(IParser<TSchema> parser, Uri uri, IDictionary<string, string> headers = null) where TSchema : SchemaBase
        {
            var settings = new HttpRequestSettings()
            {
                RequestedUri = uri
            };

            if (headers != null && headers.Count > 0)
            {
                foreach (var item in headers)
                {
                    settings.Headers[item.Key] = item.Value;
                }
            }

            HttpRequestResult httpResult = await DownloadAsync(settings);
            HttpRequestResult<TSchema> result;
            result = new HttpRequestResult<TSchema>(httpResult);
            if (httpResult.Success)
            {
                var items = await parser.ParseAsync(httpResult.Result);
                if (items == null)
                {
                    items = new TSchema[0];
                }
                result.Items = items;
            }

            return result;
        }

        internal static async Task<HttpRequestResult> DownloadAsync(HttpRequestSettings settings)
        {
            var result = new HttpRequestResult();
            HttpResponseMessage response = await GetResponseMessage(settings);
            result.StatusCode = response.StatusCode;
            FixInvalidCharset(response);
            SetEncoding(response);
            var content = await response.Content.ReadAsStringAsync();
            result.Result = content;
            return result;
        }

        internal static async Task<HttpRequestResult> DownloadRssAsync(HttpRequestSettings settings)
        {
            var result = new HttpRequestResult();
            HttpResponseMessage response = await GetResponseMessage(settings);
            result.StatusCode = response.StatusCode;
            FixInvalidCharset(response);
            await SetRssEncoding(response);
            var content = await response.Content.ReadAsStringAsync();
            result.Result = content;
            return result;
        }

        private static async Task<HttpResponseMessage> GetResponseMessage(HttpRequestSettings settings)
        {
            var filter = new HttpBaseProtocolFilter();
            filter.CacheControl.ReadBehavior = HttpCacheReadBehavior.MostRecent;

            var httpClient = new HttpClient(filter);

            AddRequestHeaders(httpClient, settings);

            HttpResponseMessage response = await httpClient.GetAsync(settings.RequestedUri);
            return response;
        }

        private static void AddRequestHeaders(HttpClient httpClient, HttpRequestSettings settings)
        {
            if (!string.IsNullOrEmpty(settings.UserAgent))
            {
                httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(settings.UserAgent);
            }

            if (settings.Headers != null)
            {
                foreach (var customHeaderName in settings.Headers.AllKeys)
                {
                    if (!String.IsNullOrEmpty(settings.Headers[customHeaderName]))
                    {
                        if (customHeaderName.ToLower() == "user-agent")
                        {
                            settings.Headers[customHeaderName] += $" {GetWASSufix()}";
                        }
                        httpClient.DefaultRequestHeaders[customHeaderName] = settings.Headers[customHeaderName];
                    }

                }
            }
        }

        private static void FixInvalidCharset(HttpResponseMessage response)
        {
            if (response?.Content?.Headers?.ContentType?.CharSet != null)
            {
                // Fix invalid charset returned by some web sites.
                string charset = response.Content.Headers.ContentType.CharSet;
                if (charset.Contains("\""))
                {
                    response.Content.Headers.ContentType.CharSet = charset.Replace("\"", string.Empty);
                }

            }
        }

        private async static Task SetRssEncoding(HttpResponseMessage response)
        {
            if (response?.Content?.Headers?.ContentType?.CharSet != null)
            {
                if (response.Content.Headers.ContentType.MediaType?.ToLower().Contains("xml") == true)
                {
                    string charset = response.Content.Headers.ContentType.CharSet;
                    if (string.IsNullOrEmpty(charset))
                    {
                        var content = await response.Content.ReadAsStringAsync();
                        var encoding = "UTF-8";
                        try
                        {
                            var doc = XDocument.Parse(content);
                            if (!string.IsNullOrEmpty(doc?.Declaration?.Encoding))
                            {
                                encoding = doc.Declaration.Encoding;
                            }
                            response.Content.Headers.ContentType.CharSet = encoding;
                        }
                        catch (XmlException)
                        {
                            response.Content.Headers.ContentType.CharSet = charset;
                        }

                    }
                }
            }
        }

        private static void SetEncoding(HttpResponseMessage response)
        {
            if (string.IsNullOrEmpty(response?.Content?.Headers?.ContentType?.CharSet))
            {
                response.Content.Headers.ContentType.CharSet = "utf-8";
            }
        }

        internal static string GetWASSufix()
        {
            return  $"WAS/{AssemblyUtils.GetVersion()}";
        }
    }
}


text:
html{
  min-width: 800px;
  margin: 10px 5px 5px 5px;

}

#container .slider {
  display: inline-block;
}

#container #slider-wrapper {
  margin-top: 10px;
  margin-bottom: 10px;
  vertical-align: middle;
  width: 71%;
  margin-left: 1%;
}

#container .slider.slider-horizontal {
  vertical-align: middle;
  height: 20px;
  position: relative;
  width: 80% !important;
}

#container .slider.slider-horizontal .slider-track {
  height: 10px;
  width: 99%;
  vertical-align: middle;
  top: 50%;
}

#container .slider.slider-horizontal .slider-selection {
  height: 100%;
  top: 0;
  bottom: 0;
}

#container .slider.slider-horizontal .slider-handle {
  margin-top: -5px;
  margin-left: -5px;
}

#container .slider.slider-horizontal .slider-handle.triangle {
  border-width: 0 10px 10px 10px;
  width: 0;
  height: 0;
  border-bottom-color: #0480be;
  margin-top: 0;
}

#container .slider.slider-vertical {
  height: 210px;
  width: 20px;
}

#container .slider.slider-vertical .slider-track {
  width: 10px;
  height: 100%;
  margin-left: -5px;
  left: 50%;
  top: 0;
}

#container .slider.slider-vertical .slider-selection {
  width: 100%;
  left: 0;
  top: 0;
  bottom: 0;
}

#container .slider.slider-vertical .slider-handle {
  margin-left: -5px;
  margin-top: -10px;
}

#container .slider.slider-vertical .slider-handle.triangle {
  border-width: 10px 0 10px 10px;
  width: 1px;
  height: 1px;
  border-left-color: #0480be;
  margin-left: 0;
}

#container .slider input {
  display: none;
}

#container .slider .tooltip-inner {
  white-space: nowrap;
}

#container .slider-track {
  position: absolute;
  cursor: pointer;
  background-color: #f7f7f7;
  background-image: -moz-linear-gradient(top, #f5f5f5, #f9f9f9);
  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#f5f5f5), to(#f9f9f9));
  background-image: -webkit-linear-gradient(top, #f5f5f5, #f9f9f9);
  background-image: -o-linear-gradient(top, #f5f5f5, #f9f9f9);
  background-image: linear-gradient(to bottom, #f5f5f5, #f9f9f9);
  background-repeat: repeat-x;
  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff5f5f5', endColorstr='#fff9f9f9', GradientType=0);
  -webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
  -moz-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
  box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
  -webkit-border-radius: 4px;
  -moz-border-radius: 4px;
  border-radius: 4px;
}

#container .slider-selection {
  position: absolute;
  background-color: #f7f7f7;
  background-image: -moz-linear-gradient(top, #f9f9f9, #f5f5f5);
  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#f9f9f9), to(#f5f5f5));
  background-image: -webkit-linear-gradient(top, #f9f9f9, #f5f5f5);
  background-image: -o-linear-gradient(top, #f9f9f9, #f5f5f5);
  background-image: linear-gradient(to bottom, #f9f9f9, #f5f5f5);
  background-repeat: repeat-x;
  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff9f9f9', endColorstr='#fff5f5f5', GradientType=0);
  -webkit-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
  -moz-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
  box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
  -webkit-box-sizing: border-box;
  -moz-box-sizing: border-box;
  box-sizing: border-box;
  -webkit-border-radius: 4px;
  -moz-border-radius: 4px;
  border-radius: 4px;
}

#container .slider-handle {
  position: absolute;
  width: 20px;
  height: 20px;
  background-color: #0e90d2;
  background-image: -moz-linear-gradient(top, #149bdf, #0480be);
  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#149bdf), to(#0480be));
  background-image: -webkit-linear-gradient(top, #149bdf, #0480be);
  background-image: -o-linear-gradient(top, #149bdf, #0480be);
  background-image: linear-gradient(to bottom, #149bdf, #0480be);
  background-repeat: repeat-x;
  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff149bdf', endColorstr='#ff0480be', GradientType=0);
  -webkit-box-shadow: inset 0 1px 0 rgba(255,255,255,.2), 0 1px 2px rgba(0,0,0,.05);
  -moz-box-shadow: inset 0 1px 0 rgba(255,255,255,.2), 0 1px 2px rgba(0,0,0,.05);
  box-shadow: inset 0 1px 0 rgba(255,255,255,.2), 0 1px 2px rgba(0,0,0,.05);
  opacity: 0.8;
  border: 0px solid transparent;
}

#container .slider-handle.round {
  -webkit-border-radius: 20px;
  -moz-border-radius: 20px;
  border-radius: 20px;
}

#container .slider-handle.triangle {
  background: transparent none;
}


text:
Testing

Coming soon, we are working hard on this section.