answer
stringlengths 15
1.25M
|
|---|
# This migration comes from thinkspace_resource (originally 20150502000000)
class <API key> < ActiveRecord::Migration
def change
add_column :<API key>, :file_fingerprint, :string
end
end
|
package com.microsoft.azure.management.network.v2020_04_01;
import java.util.Map;
import com.fasterxml.jackson.annotation.JsonProperty;
/**
* Tags object for patch operations.
*/
public class TagsObject {
/**
* Resource tags.
*/
@JsonProperty(value = "tags")
private Map<String, String> tags;
/**
* Get resource tags.
*
* @return the tags value
*/
public Map<String, String> tags() {
return this.tags;
}
/**
* Set resource tags.
*
* @param tags the tags value to set
* @return the TagsObject object itself.
*/
public TagsObject withTags(Map<String, String> tags) {
this.tags = tags;
return this;
}
}
|
package org.spongepowered.common.mixin.core.server.network;
import net.minecraft.network.NetworkManager;
import net.minecraft.network.login.server.S00PacketDisconnect;
import net.minecraft.server.MinecraftServer;
import net.minecraft.server.management.<API key>;
import net.minecraft.server.network.<API key>;
import net.minecraft.util.<API key>;
import net.minecraft.util.IChatComponent;
import org.apache.logging.log4j.Logger;
import org.spongepowered.api.event.cause.NamedCause;
import org.spongepowered.api.profile.GameProfile;
import org.spongepowered.api.event.SpongeEventFactory;
import org.spongepowered.api.event.cause.Cause;
import org.spongepowered.api.event.network.<API key>;
import org.spongepowered.api.network.RemoteConnection;
import org.spongepowered.api.text.Text;
import org.spongepowered.asm.lib.Opcodes;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.Redirect;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
import org.spongepowered.common.SpongeImpl;
import org.spongepowered.common.interfaces.<API key>;
import org.spongepowered.common.text.SpongeTexts;
import java.net.SocketAddress;
import java.util.Optional;
@Mixin(<API key>.class)
public abstract class <API key> implements <API key> {
@Shadow private static Logger logger;
@Shadow public NetworkManager networkManager;
@Shadow private MinecraftServer server;
@Shadow private com.mojang.authlib.GameProfile loginGameProfile;
@Shadow public abstract String getConnectionInfo();
@Shadow public abstract com.mojang.authlib.GameProfile getOfflineProfile(com.mojang.authlib.GameProfile profile);
@Redirect(method = "tryAcceptPlayer", at = @At(value = "INVOKE", target = "Lnet/minecraft/server/management/<API key>;"
+ "allowUserToConnect(Ljava/net/SocketAddress;Lcom/mojang/authlib/GameProfile;)Ljava/lang/String;"))
public String <API key>(<API key> confMgr, SocketAddress address, com.mojang.authlib.GameProfile profile) {
return null; // We handle disconnecting
}
private void closeConnection(IChatComponent reason) {
try {
logger.info("Disconnecting " + this.getConnectionInfo() + ": " + reason.getUnformattedText());
this.networkManager.sendPacket(new S00PacketDisconnect(reason));
this.networkManager.closeChannel(reason);
} catch (Exception exception) {
logger.error("Error whilst disconnecting player", exception);
}
}
private void disconnectClient(Optional<Text> disconnectMessage) {
IChatComponent reason = null;
if (disconnectMessage.isPresent()) {
reason = SpongeTexts.toComponent(disconnectMessage.get());
} else {
reason = new <API key>("disconnect.disconnected");
}
this.closeConnection(reason);
}
@Override
public boolean fireAuthEvent() {
Optional<Text> disconnectMessage = Optional.of(Text.of("You are not allowed to log in to this server."));
<API key>.Auth event = SpongeEventFactory.<API key>(Cause.of(NamedCause.source(this.loginGameProfile)),
disconnectMessage, disconnectMessage, (RemoteConnection) this.networkManager, (GameProfile) this.loginGameProfile);
SpongeImpl.postEvent(event);
if (event.isCancelled()) {
this.disconnectClient(event.getMessage());
}
return event.isCancelled();
}
@Inject(method = "processLoginStart", at = @At(value = "FIELD", target = "Lnet/minecraft/server/network/<API key>;"
+ "currentLoginState:Lnet/minecraft/server/network/<API key>$LoginState;",
opcode = Opcodes.PUTFIELD, ordinal = 1), cancellable = true)
public void <API key>(CallbackInfo ci) {
// Move this check up here, so that the UUID isn't null when we fire the event
if (!this.loginGameProfile.isComplete()) {
this.loginGameProfile = this.getOfflineProfile(this.loginGameProfile);
}
if (this.fireAuthEvent()) {
ci.cancel();
}
}
}
|
from otp.ai.AIBaseGlobal import *
import <API key>
from direct.directnotify import DirectNotifyGlobal
from direct.fsm import ClassicFSM, State
from direct.fsm import State
from direct.task import Task
import random
from toontown.toonbase import ToontownGlobals
from toontown.toonbase import TTLocalizer
import CharStateDatasAI
class <API key>(<API key>.<API key>):
notify = DirectNotifyGlobal.directNotify.newCategory('<API key>')
def __init__(self, air):
<API key>.<API key>.__init__(self, air, TTLocalizer.Goofy)
self.fsm = ClassicFSM.ClassicFSM('<API key>', [State.State('Off', self.enterOff, self.exitOff, ['Lonely', 'TransitionToCostume', 'Walk']),
State.State('Lonely', self.enterLonely, self.exitLonely, ['Chatty', 'Walk', 'TransitionToCostume']),
State.State('Chatty', self.enterChatty, self.exitChatty, ['Lonely', 'Walk', 'TransitionToCostume']),
State.State('Walk', self.enterWalk, self.exitWalk, ['Lonely', 'Chatty', 'TransitionToCostume']),
State.State('TransitionToCostume', self.<API key>, self.<API key>, ['Off'])], 'Off', 'Off')
self.fsm.enterInitialState()
self.handleHolidays()
def delete(self):
self.fsm.requestFinalState()
<API key>.<API key>.delete(self)
self.lonelyDoneEvent = None
self.lonely = None
self.chattyDoneEvent = None
self.chatty = None
self.walkDoneEvent = None
self.walk = None
return
def generate(self):
<API key>.<API key>.generate(self)
name = self.getName()
self.lonelyDoneEvent = self.taskName(name + '-lonely-done')
self.lonely = CharStateDatasAI.CharLonelyStateAI(self.lonelyDoneEvent, self)
self.chattyDoneEvent = self.taskName(name + '-chatty-done')
self.chatty = CharStateDatasAI.CharChattyStateAI(self.chattyDoneEvent, self)
self.walkDoneEvent = self.taskName(name + '-walk-done')
if self.diffPath == None:
self.walk = CharStateDatasAI.CharWalkStateAI(self.walkDoneEvent, self)
else:
self.walk = CharStateDatasAI.CharWalkStateAI(self.walkDoneEvent, self, self.diffPath)
return
def walkSpeed(self):
return ToontownGlobals.GoofySpeed
def start(self):
self.fsm.request('Lonely')
def __decideNextState(self, doneStatus):
if self.transitionToCostume == 1:
curWalkNode = self.walk.getDestNode()
if simbase.air.holidayManager:
if ToontownGlobals.HALLOWEEN_COSTUMES in simbase.air.holidayManager.currentHolidays and simbase.air.holidayManager.currentHolidays[ToontownGlobals.HALLOWEEN_COSTUMES]:
simbase.air.holidayManager.currentHolidays[ToontownGlobals.HALLOWEEN_COSTUMES].triggerSwitch(curWalkNode, self)
self.fsm.request('TransitionToCostume')
elif ToontownGlobals.<API key> in simbase.air.holidayManager.currentHolidays and simbase.air.holidayManager.currentHolidays[ToontownGlobals.<API key>]:
simbase.air.holidayManager.currentHolidays[ToontownGlobals.<API key>].triggerSwitch(curWalkNode, self)
self.fsm.request('TransitionToCostume')
else:
self.notify.warning('transitionToCostume == 1 but no costume holiday')
else:
self.notify.warning('transitionToCostume == 1 but no holiday Manager')
if doneStatus['state'] == 'lonely' and doneStatus['status'] == 'done':
self.fsm.request('Walk')
elif doneStatus['state'] == 'chatty' and doneStatus['status'] == 'done':
self.fsm.request('Walk')
elif doneStatus['state'] == 'walk' and doneStatus['status'] == 'done':
if len(self.nearbyAvatars) > 0:
self.fsm.request('Chatty')
else:
self.fsm.request('Lonely')
def enterOff(self):
pass
def exitOff(self):
<API key>.<API key>.exitOff(self)
def enterLonely(self):
self.lonely.enter()
self.acceptOnce(self.lonelyDoneEvent, self.__decideNextState)
def exitLonely(self):
self.ignore(self.lonelyDoneEvent)
self.lonely.exit()
def __goForAWalk(self, task):
self.notify.debug('going for a walk')
self.fsm.request('Walk')
return Task.done
def enterChatty(self):
self.chatty.enter()
self.acceptOnce(self.chattyDoneEvent, self.__decideNextState)
def exitChatty(self):
self.ignore(self.chattyDoneEvent)
self.chatty.exit()
def enterWalk(self):
self.notify.debug('going for a walk')
self.walk.enter()
self.acceptOnce(self.walkDoneEvent, self.__decideNextState)
def exitWalk(self):
self.ignore(self.walkDoneEvent)
self.walk.exit()
def <API key>(self):
if len(self.nearbyAvatars) == 1:
if self.fsm.getCurrentState().getName() != 'Walk':
self.fsm.request('Chatty')
else:
self.notify.debug('<API key>: in walk state')
else:
self.notify.debug('<API key>: num avatars: ' + str(len(self.nearbyAvatars)))
def avatarExitNextState(self):
if len(self.nearbyAvatars) == 0:
if self.fsm.getCurrentState().getName() != 'Walk':
self.fsm.request('Lonely')
def handleHolidays(self):
<API key>.<API key>.handleHolidays(self)
if hasattr(simbase.air, 'holidayManager'):
if ToontownGlobals.<API key> in simbase.air.holidayManager.currentHolidays:
if simbase.air.holidayManager.currentHolidays[ToontownGlobals.<API key>] != None and simbase.air.holidayManager.currentHolidays[ToontownGlobals.<API key>].getRunningState():
self.diffPath = TTLocalizer.Donald
return
def getCCLocation(self):
if self.diffPath == None:
return 1
else:
return 0
return
def <API key>(self):
pass
def <API key>(self):
pass
|
<?php
namespace Rmc\Core\StaticPageBundle\DependencyInjection;
use Symfony\Component\Config\Definition\Builder\TreeBuilder;
use Symfony\Component\Config\Definition\<API key>;
class Configuration implements <API key>
{
/**
* {@inheritDoc}
*/
public function <API key>()
{
$treeBuilder = new TreeBuilder();
$rootNode = $treeBuilder->root('<API key>');
$rootNode
->children()
->arrayNode('static_page')
->children()
->scalarNode('is_enabled')->end()
->scalarNode('source')->end()
->scalarNode('entity_manager_name')->end()
->scalarNode('entity_class')->end()
->scalarNode('local_feed_path')->defaultFalse()->end()
->end()
->end()
->end();
// Here you should define the parameters that are allowed to
// configure your bundle. See the documentation linked above for
// more information on that topic.
return $treeBuilder;
}
}
|
<!--?xml version="1.0"?--><html><head></head><body></body></html>
|
import React from 'react';
import {
Link
} from 'react-router';
import HotdotActions from '../actions/HotdotActions';
import HotdotObjStore from '../stores/HotdotObjStore';
import MyInfoNavbar from './MyInfoNavbar';
import Weixin from './Weixin';
class Hotdot extends React.Component {
constructor(props) {
super(props);
this.state = HotdotObjStore.getState();
this.onChange = this.onChange.bind(this);
}
componentDidMount() {
HotdotActions.getHotdotDatas();
$(".month-search").hide();
$(".navbar-hotdot").on("touchend",function(){
var index = $(this).index();
if(index==0){
$(".month-search").hide();
$(".week-search").show();
}else{
$(".month-search").show();
$(".week-search").hide();
}
});
HotdotObjStore.listen(this.onChange);
Weixin.getUrl();
Weixin.weixinReady();
}
<API key>() {
HotdotObjStore.unlisten(this.onChange);
}
onChange(state) {
this.setState(state);
}
getUpOrDown(curData,preData,isWeek){
var preDataItem = isWeek ? preData.week:preData.month;
if(preData==false || preData == [] || preDataItem==undefined){
return (<span className="hotdotRight"><span className="glyphicon-trend glyphicon glyphicon-arrow-up"></span>
<span className="badge">{curData.value}</span></span>);
}else{
for(var i = 0;i < preDataItem.length;i++){
if(preDataItem[i].word == curData.word){
if(preDataItem[i].value < curData.value){
return (<span className="hotdotRight"><span className="glyphicon-trend glyphicon glyphicon-arrow-up"></span>
<span className="badge">{curData.value}</span></span>);
}else{
return (<span className="hotdotRight"><span className="glyphicon-trend glyphicon <API key>"></span>
<span className="badge" style={{backgroundColor:"#4F81E3"}}>{curData.value}</span></span>);
}
}
}
}
return (<span className="hotdotRight"><span className="glyphicon-trend glyphicon glyphicon-arrow-up"></span>
<span className="badge">{curData.value}</span></span>);
}
render() {
var hotdotData = (this.state.data);
var firstHotData = hotdotData[0];
var preHotData ;
if(hotdotData.length > 7){
preHotData = hotdotData[7];
}else{
preHotData = [];
}
if(firstHotData){
var weekList = firstHotData.week.map((weekItem,i)=>(
<li className="list-group-item" key={i}>
{this.getUpOrDown(weekItem,preHotData,true)}
{weekItem.word}
</li>
));
if(weekList.length==0){
weekList = <div className = "noData">,</div>
}
var monthList = firstHotData.month.map((monthItem,i)=>(
<li className="list-group-item" key={i}>
{this.getUpOrDown(monthItem,preHotData,false)}
{monthItem.word}
</li>
));
if(monthList.length==0){
monthList = <div className = "noData">Whops,,</div>
}
}else{
var weekList = (<span>...</span>);
var monthList = (<span>...</span>);
}
return (<div>
<div className="content-container">
<div className="week-search">
<div className="panel panel-back">
<div className="panel-heading">
<span className="panel-title"></span>
<div className="<API key>">
<span className="navbar-hotdot navbar-week <API key>"></span>
<span className="navbar-hotdot navbar-month"></span>
</div>
</div>
<div className="panel-body">
<ul className="list-group">
{weekList}
</ul>
</div>
</div>
</div>
<div className="month-search">
<div className="panel panel-back">
<div className="panel-heading">
<span className="panel-title"></span>
<div className="<API key>">
<span className="navbar-hotdot navbar-week"></span>
<span className="navbar-hotdot navbar-month <API key>"></span>
</div>
</div>
<div className="panel-body">
<ul className="list-group">
{monthList}
</ul>
</div>
</div>
</div>
</div>
</div>);
}
}
export default Hotdot;
|
#ifndef CLIENTVERSION_H
#define CLIENTVERSION_H
// These need to be macros, as version.cpp's and bitcoin-qt.rc's voodoo requires it
#define <API key> 1
#define <API key> 5
#define <API key> 1
#define <API key> 0
// Set to true for release, false for prerelease or test build
#define <API key> true
#define COPYRIGHT_YEAR 2014
// Converts the parameter X to a string after macro replacement on X has been performed.
// Don't merge these into one macro!
#define STRINGIZE(X) DO_STRINGIZE(X)
#define DO_STRINGIZE(X)
#endif // CLIENTVERSION_H
|
<?php
namespace PayU\Api\Response\Builder;
use PayU\Api\Request\RequestInterface;
use PayU\Api\Response\AbstractResponse;
use Psr\Http\Message\ResponseInterface;
/**
* Interface BuilderInterface
*
* Provides a common interface to build response objects based on request context
*
* @package PayU\Api\Response\Builder
* @author Lucas Mendes <devsdmf@gmail.com>
*/
interface BuilderInterface
{
/**
* Build a response object
*
* @param RequestInterface $request
* @param ResponseInterface $response
* @param string $context
* @return AbstractResponse
*/
public function build(RequestInterface $request, ResponseInterface $response, $context = null);
}
|
using SolrExpress.Search.Parameter;
using System;
using System.Globalization;
using System.Linq;
using System.Text;
namespace SolrExpress.Utility
{
<summary>
Helper class used to extract information inside parameters
</summary>
internal static class ParameterUtil
{
<summary>
Get the sort type and direction
</summary>
<param name="solrFacetSortType">Type used in match</param>
<param name="typeName">Type name</param>
<param name="sortName">Sort direction</param>
public static void GetFacetSort(FacetSortType solrFacetSortType, out string typeName, out string sortName)
{
switch (solrFacetSortType)
{
case FacetSortType.IndexAsc:
typeName = "index";
sortName = "asc";
break;
case FacetSortType.IndexDesc:
typeName = "index";
sortName = "desc";
break;
case FacetSortType.CountAsc:
typeName = "count";
sortName = "asc";
break;
case FacetSortType.CountDesc:
typeName = "count";
sortName = "desc";
break;
default:
throw new ArgumentException(nameof(solrFacetSortType));
}
}
<summary>
Calculate and returns spatial formule
</summary>
<param name="fieldName">Field name</param>
<param name="functionType">Function used in spatial filter</param>
<param name="centerPoint">Center point to spatial filter</param>
<param name="distance">Distance from center point</param>
<returns>Spatial formule</returns>
internal static string GetSpatialFormule(string fieldName, SpatialFunctionType functionType, GeoCoordinate centerPoint, decimal distance)
{
var functionTypeStr = functionType.ToString().ToLower();
var latitude = centerPoint.Latitude.ToString("G", CultureInfo.InvariantCulture);
var longitude = centerPoint.Longitude.ToString("G", CultureInfo.InvariantCulture);
var distanceStr = distance.ToString("G", CultureInfo.InvariantCulture);
return $"{{!{functionTypeStr} sfield={fieldName} pt={latitude},{longitude} d={distanceStr}}}";
}
<summary>
Get the field with excludes
</summary>
<param name="excludes">Excludes tags</param>
<param name="aliasName">Alias name</param>
<param name="fieldName">Field name</param>
internal static string GetFacetName(string[] excludes, string aliasName, string fieldName)
{
var sb = new StringBuilder();
var needsBraces = (excludes?.Any() ?? false) || !string.IsNullOrWhiteSpace(aliasName);
if (needsBraces)
{
sb.Append("{!");
}
if (excludes?.Any() ?? false)
{
sb.Append($"ex={string.Join(",", excludes)}");
}
if (sb.Length > 2)
{
sb.Append(" ");
}
if (!string.IsNullOrWhiteSpace(aliasName))
{
sb.Append($"key={aliasName}");
}
if (needsBraces)
{
sb.Append("}");
}
sb.Append(fieldName);
return sb.ToString();
}
<summary>
Get the filter with tag
</summary>
<param name="query">Query value</param>
<param name="aliasName">Alias name</param>
public static string GetFilterWithTag(string query, string aliasName)
{
return !string.IsNullOrWhiteSpace(aliasName) ? $"{{!tag={aliasName}}}{query}" : query;
}
}
}
|
import 'babel-polyfill';
import ReactDOM from 'react-dom';
import React from 'react';
import FastClick from 'fastclick';
import Router from './routes';
import Location from './core/Location';
import { addEventListener, removeEventListener } from './core/DOMUtils';
import { ApolloClient, <API key> } from 'react-apollo';
function getCookie(name) {
let value = "; " + document.cookie;
let parts = value.split("; " + name + "=");
if (parts.length == 2) return parts.pop().split(";").shift();
}
const networkInterface = <API key>('/graphql', {
credentials: 'same-origin',
uri: '/graphql',
headers: {
Cookie: getCookie("id_token")
}
});
const client = new ApolloClient({
connectToDevTools: true,
networkInterface: networkInterface,
});
let cssContainer = document.getElementById('css');
const appContainer = document.getElementById('app');
const context = {
insertCss: styles => styles._insertCss(),
onSetTitle: value => (document.title = value),
onSetMeta: (name, content) => {
// Remove and create a new <meta /> tag in order to make it work
// with bookmarks in Safari
const elements = document.<API key>('meta');
Array.from(elements).forEach((element) => {
if (element.getAttribute('name') === name) {
element.parentNode.removeChild(element);
}
});
const meta = document.createElement('meta');
meta.setAttribute('name', name);
meta.setAttribute('content', content);
document
.<API key>('head')[0]
.appendChild(meta);
},
client
};
// Google Analytics tracking. Don't send 'pageview' event after the first
// rendering, as it was already sent by the Html component.
let trackPageview = () => (trackPageview = () => window.ga('send', 'pageview'));
function render(state) {
Router.dispatch(state, (newState, component) => {
ReactDOM.render( component, appContainer,
() => {
// Restore the scroll position if it was saved into the state
if (state.scrollY !== undefined) {
window.scrollTo(state.scrollX, state.scrollY);
} else {
window.scrollTo(0, 0);
}
trackPageview();
// Remove the pre-rendered CSS because it's no longer used
// after the React app is launched
if (cssContainer) {
cssContainer.parentNode.removeChild(cssContainer);
cssContainer = null;
}
});
});
}
function run() {
let currentLocation = null;
let currentState = null;
// Make taps on links and buttons work fast on mobiles
FastClick.attach(document.body);
// Re-render the app when window.location changes
const unlisten = Location.listen(location => {
currentLocation = location;
currentState = Object.assign({}, location.state, {
path: location.pathname,
query: location.query,
state: location.state,
context,
});
render(currentState);
});
// Save the page scroll position into the current location's state
const supportPageOffset = window.pageXOffset !== undefined;
const isCSS1Compat = ((document.compatMode || '') === 'CSS1Compat');
const setPageOffset = () => {
currentLocation.state = currentLocation.state || Object.create(null);
if (supportPageOffset) {
currentLocation.state.scrollX = window.pageXOffset;
currentLocation.state.scrollY = window.pageYOffset;
} else {
currentLocation.state.scrollX = isCSS1Compat ?
document.documentElement.scrollLeft : document.body.scrollLeft;
currentLocation.state.scrollY = isCSS1Compat ?
document.documentElement.scrollTop : document.body.scrollTop;
}
};
addEventListener(window, 'scroll', setPageOffset);
addEventListener(window, 'pagehide', () => {
removeEventListener(window, 'scroll', setPageOffset);
unlisten();
});
}
// Run the application when both DOM is ready and page content is loaded
if (['complete', 'loaded', 'interactive'].includes(document.readyState) && document.body) {
run();
} else {
document.addEventListener('DOMContentLoaded', run, false);
}
|
var $M = require("@effectful/debugger"),
$x = $M.context,
$ret = $M.ret,
$unhandled = $M.unhandled,
$brk = $M.brk,
$lset = $M.lset,
$mcall = $M.mcall,
$m = $M.module("file.js", null, typeof module === "undefined" ? null : module, null, "$", {
__webpack_require__: typeof __webpack_require__ !== "undefined" && __webpack_require__
}, null),
$s$1 = [{
e: [1, "1:9-1:10"]
}, null, 0],
$s$2 = [{}, $s$1, 1],
$m$0 = $M.fun("m$0", "file.js", null, null, [], 0, 2, "1:0-4:0", 32, function ($, $l, $p) {
for (;;) switch ($.state = $.goto) {
case 0:
$lset($l, 1, $m$1($));
$.goto = 2;
continue;
case 1:
$.goto = 2;
return $unhandled($.error);
case 2:
return $ret($.result);
default:
throw new Error("Invalid state");
}
}, null, null, 0, [[0, "1:0-3:1", $s$1], [16, "4:0-4:0", $s$1], [16, "4:0-4:0", $s$1]]),
$m$1 = $M.fun("m$1", "e", null, $m$0, [], 0, 2, "1:0-3:1", 0, function ($, $l, $p) {
for (;;) switch ($.state = $.goto) {
case 0:
$.goto = 1;
$brk();
$.state = 1;
case 1:
$.goto = 2;
$p = ($x.call = eff)(1);
$.state = 2;
case 2:
$l[1] = $p;
$.goto = 3;
$p = ($x.call = eff)(2);
$.state = 3;
case 3:
$.goto = 4;
$mcall("log", console, $l[1] + $p);
$.state = 4;
case 4:
$.goto = 6;
$brk();
continue;
case 5:
$.goto = 6;
return $unhandled($.error);
case 6:
return $ret($.result);
default:
throw new Error("Invalid state");
}
}, null, null, 1, [[4, "2:2-2:31", $s$2], [2, "2:14-2:20", $s$2], [2, "2:23-2:29", $s$2], [2, "2:2-2:30", $s$2], [36, "3:1-3:1", $s$2], [16, "3:1-3:1", $s$2], [16, "3:1-3:1", $s$2]]);
$M.moduleExports();
|
# INTRODUCTION
Triplie is an AI bot based on 2nd up to 5th order Markov model. It uses an
SQLite database for storage.
Triplie learns by creating
1. a dictionary of words
2. a graph representing valid 5-grams (consecutive groups of 5 words)
encountered in the text
3. a graph of associations between words from sentences formed according to the
Hebbian rule
To respond to a user, triplie extracts keywords from the user's text, finds
their most appropriate associated keywords in the Hebbian association network,
and generates replies that contain the associated keywords using multiple
<API key> Markov chains algorithm.
For more information on installing and configuring read below
You can join the project's IRC channel too:
[#triplie on irc.freenode.net](irc://irc.freenode.net/#triplie)
# Install
## Prerequisites
Download and install [node.js](http://nodejs.org/) for your system.
Its recommended to build node from source. If you don't do that, make
sure that npm is also installed alongside with node and that the
node binary is called "node"
Then from a terminal run:
npm install -g triplie
This will install the `triplie` command on your system.
Configure the bot as explained below before running!
# CONFIGURATION
If running the bot for the first time and its not configured,
you should create a new directory and run:
triplie config.yaml --init
to create the initial config file
Edit config.yaml
config.yaml is already pre-filled with some default for your bot. You will want
to change some of these settings.
The configuration file is really well commented. Open it and edit it according
to the instructions contained inside. Once you run the bot however, the
instructions will disappear the moment you change a setting by giving a command
to the bot.
# RUNNING
After you edited the config file, to run the bot use the command:
triplie config.yaml
# IMPORT EXISTING TEXT
If called with the argument `--feed` triplie will receive data from stdin,
parse it using a regular expression then feed the database.
Example:
cat log.txt | triplie config.yaml --feed --regex '(?<year>\d+)-(?<month>\d+)-(?<day>)T(?<hour>\d+):(?<minute>\d+):(?<second>\d+)Z\s+(?<nick>.+):\s+(?<text>.+)'
will work for a `log.txt` that has lines in the format:
2013-04-04T13:15:00Z someuser: I wrote some text
The syntax is XRegExp and uses named groups. See
[the XRegExp readme](https://npmjs.org/package/xregexp) for more info
Currently, supported named captures are:
* year
* month
* day
* hour
* minute
* second
* timestamp - unix timestamp in seconds, used instead of the date captures
* timestampms - unix timestamp in miliseconds, used instead of both above.
* text - the text content
Timestamp example:
cat log.txt | triplie config.yaml --feed --regex '(?<timestamp>\d+) (?<text>.+)
will match `log.txt` containing lines in the format:
1234567890 example text here
All captures except text are optional - the time is optional and if left out
the feeder will generate reasonable "fake" timestamps.
cat log.txt | triplie config.yaml --feed --regex '(?<text>.+)'
# COMMANDS
List of triplie's commands (assuming "!" is the cmdchar)
1. !join #channel - causes the bot to join and remember the channel
2. !part #channel - part and forget channel
3. !reload - causes reload of the bot code, useful for development
4. !set path value - set a config setting to the specified value. Examples
!set ai.sleep.1 10 - Set the upper sleep limit to 10 seconds
!set ai.sleep [2,3] - Set both sleep limits. Value musn't contain space.
5. !get path - get the config value at the specified path
6. !db stats - triplie will output database statistics
!cmd will return results via private notice
!!cmd returns results via public message
# LICENCE & AUTHOR
See LICENCE and AUTHORS (if present)
|
module Shiphawk
module Api
# Company API
# The following API actions provide the CRUD interface to managing a shipment's tracking.
module ShipmentsStatus
def <API key> options
put_request status_path, options
end
end
end
end
|
import "bootstrap-slider";
import "bootstrap-switch";
export module profile {
function onInfoSubmit() {
var params: { [key: string]: string } = {};
$("#info-container .info-field").each(function() {
let name: string = this.getAttribute("name");
if (name == null) {
return;
}
let value: string = $(this).val();
if ($(this).hasClass("info-slider")) {
let valueTokens: string[] = this.getAttribute("data-value").split(",");
name = name.substring(0, 1).toUpperCase() + name.substring(1);
params["min" + name] = valueTokens[0];
params["max" + name] = valueTokens[1];
return;
} else if (this.getAttribute("type") == "checkbox") {
value = (this.checked ? 1 : 0).toString();
}
params[name] = value;
});
$.post("/office/post/update-profile", params, function(data) {
$("#errors").addClass("hidden");
$("#success").removeClass("hidden");
window.scrollTo(0, 0);
}, "json").fail(function(err) {
$("#success").addClass("hidden");
$("#errors").text(`Error code ${err.status} occurred. Please contact a developer.`);
$("#errors").removeClass("hidden");
window.scrollTo(0, 0);
});
}
$(document).ready(function() {
(<any>$("#hours-slider")).bootstrapSlider({});
$("input.info-field[type='text']").on("keydown", function(evt) {
if (evt.which == 13) {
onInfoSubmit.apply(this);
}
});
$("input.info-field[type='checkbox']").each(function(index: number, element: HTMLElement) {
let $element: JQuery = $(element);
$element.bootstrapSwitch({
"state": $element.prop("checked")
});
});
$("button.iu-button[type='submit']").on("click", onInfoSubmit);
});
}
|
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// all copies or substantial portions of the Software.
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
package main
import (
"context"
"os"
"testing"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/assert"
"github.com/uber-go/dosa"
"github.com/uber-go/dosa/mocks"
)
func <API key>(t *testing.T) {
tcs := []struct {
serviceName string
expected string
}{
// service = "" -> default
{
expected: _defServiceName,
},
// service = "foo" -> foo
{
serviceName: "foo",
expected: "foo",
},
}
for _, tc := range tcs {
for _, cmd := range []string{"read", "range"} {
os.Args = []string{
"dosa",
"--service", tc.serviceName,
"query",
cmd,
"--namePrefix", "foo",
"--scope", "bar",
"--path", "../../testentity",
"TestEntity",
"StrKey:eq:foo",
}
main()
assert.Equal(t, tc.expected, options.ServiceName)
}
}
}
func <API key>(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mc := mocks.NewMockConnector(ctrl)
mc.EXPECT().Read(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
Do(func(_ context.Context, ei *dosa.EntityInfo, keys map[string]dosa.FieldValue, minimumFields []string) {
assert.NotNil(t, ei)
assert.Equal(t, dosa.FieldValue("foo"), keys["strkey"])
assert.Equal(t, []string{"strkey", "int64key"}, minimumFields)
}).Return(map[string]dosa.FieldValue{}, nil).MinTimes(1)
mc.EXPECT().Shutdown().Return(nil)
table, err := dosa.FindEntityByName("../../testentity", "TestEntity")
assert.NoError(t, err)
reg, err := newSimpleRegistrar(scope, namePrefix, table)
assert.NoError(t, err)
provideClient := func(opts GlobalOptions, scope, prefix, path, structName string) (ShellQueryClient, error) {
return newShellQueryClient(reg, mc), nil
}
queryRead := QueryRead{
QueryCmd: &QueryCmd{
QueryOptions: &QueryOptions{
Fields: "StrKey,Int64Key",
},
Scope: scopeFlag("scope"),
NamePrefix: "foo",
Path: "../../testentity",
provideClient: provideClient,
},
}
queryRead.Args.EntityName = "TestEntity"
queryRead.Args.Queries = []string{"StrKey:eq:foo"}
err = queryRead.Execute([]string{})
assert.NoError(t, err)
}
func <API key>(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mc := mocks.NewMockConnector(ctrl)
mc.EXPECT().Range(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
Do(func(_ context.Context, ei *dosa.EntityInfo, columnConditions map[string][]*dosa.Condition, minimumFields []string, token string, limit int) {
assert.NotNil(t, ei)
assert.Len(t, columnConditions, 1)
assert.Len(t, columnConditions["int64key"], 1)
assert.Equal(t, []string{"strkey", "int64key"}, minimumFields)
}).Return([]map[string]dosa.FieldValue{{"key": "value"}}, "", nil)
mc.EXPECT().Shutdown().Return(nil)
table, err := dosa.FindEntityByName("../../testentity", "TestEntity")
assert.NoError(t, err)
reg, err := newSimpleRegistrar(scope, namePrefix, table)
assert.NoError(t, err)
provideClient := func(opts GlobalOptions, scope, prefix, path, structName string) (ShellQueryClient, error) {
return newShellQueryClient(reg, mc), nil
}
queryRange := QueryRange{
QueryCmd: &QueryCmd{
QueryOptions: &QueryOptions{
Fields: "StrKey,Int64Key",
},
Scope: scopeFlag("scope"),
NamePrefix: "foo",
Path: "../../testentity",
provideClient: provideClient,
},
}
queryRange.Args.EntityName = "TestEntity"
queryRange.Args.Queries = []string{"Int64Key:lt:200"}
err = queryRange.Execute([]string{})
assert.NoError(t, err)
}
func <API key>(t *testing.T) {
qo := newQueryObj("StrKey", "eq", "foo")
assert.NotNil(t, qo)
assert.Equal(t, "StrKey", qo.fieldName)
assert.Equal(t, "eq", qo.op)
assert.Equal(t, "foo", qo.valueStr)
}
func <API key>(t *testing.T) {
for _, cmd := range []string{"read", "range"} {
c := StartCapture()
exit = func(r int) {}
os.Args = []string{
"dosa",
"query",
cmd,
"--namePrefix", "foo",
"--path", "../../testentity",
"TestEntity",
"StrKey:eq:foo",
}
main()
assert.Contains(t, c.stop(true), "-s, --scope' was not specified")
}
}
func <API key>(t *testing.T) {
for _, cmd := range []string{"read", "range"} {
c := StartCapture()
exit = func(r int) {}
os.Args = []string{
"dosa",
"query",
cmd,
"--scope", "foo",
"--path", "../../testentity",
"TestEntity",
"StrKey:eq:foo",
}
main()
assert.Contains(t, c.stop(true), "--namePrefix' was not specified")
}
}
func <API key>(t *testing.T) {
for _, cmd := range []string{"read", "range"} {
c := StartCapture()
exit = func(r int) {}
os.Args = []string{
"dosa",
"query",
cmd,
"--scope", "foo",
"--namePrefix", "foo",
"StrKey:eq:foo",
}
main()
assert.Contains(t, c.stop(true), "--path' was not specified")
}
}
func <API key>(t *testing.T) {
for _, cmd := range []string{"read", "range"} {
c := StartCapture()
exit = func(r int) {}
os.Args = []string{
"dosa",
"query",
cmd,
"--scope", "foo",
"--namePrefix", "foo",
"--path", "../../testentity",
"TestEntity1",
"StrKey:eq:foo",
}
main()
assert.Contains(t, c.stop(true), "no entity named TestEntity1 found")
}
}
|
<?php
// Moodle is free software: you can redistribute it and/or modify
// (at your option) any later version.
// Moodle is distributed in the hope that it will be useful,
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
defined('MOODLE_INTERNAL') || die();
$plugin->component = 'filter_podlille1'; // Full name of the plugin (used for diagnostics)
$plugin->version = 2016011101;
$plugin->requires = 2013111800; // Requires this Moodle version
$plugin->release = '1.0.3';
$plugin->maturity = MATURITY_STABLE; // This version's maturity level
|
<?php
$this->load->Model('exam/Exam_manager_model');
$this->load->model('Branch/Course_model');
$exams = $this->Exam_manager_model->exam_details();
$exam_type = $this->Exam_manager_model->get_all_exam_type();
$branch = $this->Course_model->order_by_column('c_name');
?>
<div class="row">
<div class=col-lg-12>
<!-- col-lg-12 start here -->
<div class="panel-default toggle panelMove panelClose panelRefresh"></div>
<div class=panel-body>
<?php echo form_open(base_url() . 'exam/internal_create', array('class' => 'form-horizontal <API key> validate', 'role' => 'form', 'id' => 'examform', 'target' => '_top')); ?>
<div class="padded">
<div class="form-group">
<label class="col-sm-4 control-label"><?php echo ucwords("Branch"); ?><span style="color:red">*</span></label>
<div class="col-sm-8">
<select class="form-control" name="course" id="course">
<?php foreach ($branch as $course): ?>
<option value="<?php echo $course->course_id; ?>"><?php echo $course->c_name; ?></option>
<?php endforeach; ?>
</select>
</div>
</div>
<div class="form-group">
<label class="col-sm-4 control-label"><?php echo ucwords("Semester"); ?><span style="color:red">*</span></label>
<div class="col-sm-8">
<select class="form-control" name="semester" id="semester">
</select>
</div>
</div>
<div class="form-group">
<label class="col-sm-4 control-label"><?php echo ucwords("Subejct"); ?><span style="color:red">*</span></label>
<div class="col-sm-8">
<select class="form-control" name="subject" id="subject">
</select>
</div>
</div>
<div class="form-group">
<label class="col-sm-4 control-label"><?php echo ucwords("Title"); ?><span style="color:red">*</span></label>
<div class="col-sm-8">
<input type="text" class="form-control" name="exam_name" id="exam_name"
value="<?php echo set_value('exam_name'); ?>"/>
</div>
</div>
<div class="form-group">
<label class="col-sm-4 control-label"><?php echo ucwords("Total Marks"); ?><span style="color:red">*</span></label>
<div class="col-sm-8">
<input type="number" class="form-control" name="total_marks" id="total_marks" min="0"
value="<?php echo set_value('total_marks'); ?>"/>
</div>
</div>
<div class="form-group">
<div class="col-sm-offset-4 col-sm-8">
<button type="submit" class="btn btn-info vd_bg-green"><?php echo ucwords("Add"); ?></button>
</div>
</div>
<?php echo form_close(); ?>
</div>
</div>
<!-- End .panel -->
</div>
<!-- col-lg-12 end here -->
</div>
<script>
$(document).ready(function () {
var js_date_format = '<?php echo js_dateformat(); ?>';
var date = '';
var start_date = '';
$('#edit_start_date').datepicker({
format: js_date_format,
startDate: new Date(),
autoclose: true,
todayHighlight: true,
});
$('#edit_start_date').on('change', function () {
date = new Date($(this).val());
start_date = (date.getMonth() + 1) + '/' + date.getDate() + '/' + date.getFullYear();
console.log(start_date);
setTimeout(function () {
$("#edit_end_date_time").datepicker({
format: js_date_format,
autoclose: true,
startDate: start_date
});
}, 700);
});
})
</script>
<script type="text/javascript">
$.validator.setDefaults({
submitHandler: function (form) {
form.submit();
}
});
$().ready(function () {
$("#examform").validate({
rules: {
course: "required",
semester: "required",
subject:"required",
exam_name:"required",
total_marks: "required"
},
messages: {
course: "Select branch",
semester: "Select semester",
subject:"Select subject",
exam_name:"Enter title",
total_marks: "Enter total marks",
}
});
});
</script>
<script>
$(document).ready(function () {
//course by degree
$('#degree').on('change', function () {
var course_id = $('#course').val();
var degree_id = $(this).val();
//remove all present element
$('#course').find('option').remove().end();
$('#course').append('<option value="">Select</option>');
var degree_id = $(this).val();
$.ajax({
url: '<?php echo base_url(); ?>branch/department_branch/' + degree_id,
type: 'get',
success: function (content) {
var course = jQuery.parseJSON(content);
$.each(course, function (key, value) {
$('#course').append('<option value=' + value.course_id + '>' + value.c_name + '</option>');
})
}
})
<API key>(degree_id, course_id);
});
//batch from course and degree
$('#course').on('change', function () {
var course_id = $(this).val();
<API key>(course_id);
})
//find batch from degree and course
function <API key>(degree_id, course_id) {
//remove all element from batch
$('#batch').find('option').remove().end();
$.ajax({
url: '<?php echo base_url(); ?>batch/<API key>/' + degree_id + '/' + course_id,
type: 'get',
success: function (content) {
$('#batch').append('<option value="">Select</option>');
var batch = jQuery.parseJSON(content);
console.log(batch);
$.each(batch, function (key, value) {
$('#batch').append('<option value=' + value.b_id + '>' + value.b_name + '</option>');
})
}
})
}
function <API key>(course_id,semester_id)
{
$('#subject').find('option').remove().end();
$.ajax({
url: '<?php echo base_url(); ?>subject/<API key>/' + course_id +'/'+semester_id,
type: 'get',
success: function (content) {
$('#subject').append('<option value="">Select</option>');
var subject = jQuery.parseJSON(content);
$.each(subject, function (key, value) {
$('#subject').append('<option value=' + value.sm_id + '>' + value.subject_name + '</option>');
})
}
})
}
//get semester from brach
function <API key>(branch_id) {
$('#semester').find('option').remove().end();
$.ajax({
url: '<?php echo base_url(); ?>semester/semester_branch/' + branch_id,
type: 'get',
success: function (content) {
$('#semester').append('<option value="">Select</option>');
var semester = jQuery.parseJSON(content);
$.each(semester, function (key, value) {
$('#semester').append('<option value=' + value.s_id + '>' + value.s_name + '</option>');
})
}
})
}
$("#semester").change(function(){
var course_id = $("#course").val();
var semester_id = $(this).val();
<API key>(course_id,semester_id);
});
})
</script>
<script>
$(document).ready(function () {
$('#total_marks').on('blur', function () {
var total_marks = $(this).val();
$('#passing_marks').attr('max', total_marks);
$('#passing_marks').attr('required', '');
});
$('#passing_marks').on('focus', function () {
var total_marks = $('#total_marks').val();
$(this).attr('max', total_marks);
})
})
</script>
<script>
$(document).ready(function () {
var date = '';
var start_date = '';
$("#date").datepicker({
format: ' MM dd, yyyy',
startDate: new Date(),
todayHighlight: true,
autoclose: true
});
$('#date').on('change', function () {
date = new Date($(this).val());
start_date = (date.getMonth() + 1) + '/' + date.getDate() + '/' + date.getFullYear();
console.log(start_date);
setTimeout(function () {
$("#end_date_time").datepicker({
format: ' MM dd, yyyy',
todayHighlight: true,
startDate: start_date,
autoclose: true,
});
}, 700);
});
})
</script>
|
<?php
namespace Augwa\QuickBooks\Model;
/**
* Master Account is the list of accounts in the master list. The master
* list is the complete list of accounts prescribed by the French
* Government. These accounts can be created in the company on a need
* basis. The account create API needs to be used to create an account.
*
* Class MasterAccountModel
* @package Augwa\QuickBooks\Model
*/
class MasterAccountModel
extends AccountModel
{
/**
* @var bool
*/
private $<API key>;
/**
* Product: ALL
* Specifies whether the account has been created in the company.
*
* @return bool
*/
public function <API key>()
{
return $this-><API key>;
}
/**
* Product: ALL
* Specifies whether the account has been created in the company.
*
* @param bool $<API key>
*
* @return MasterAccountModel
*/
public function <API key>(
$<API key>
)
{
$this-><API key> = $<API key>;
return $this;
}
}
|
/**
* Entry point for CSS.
*/
.foo {
color: black;
}
|
require 'spec_helper'
module Gisele
module Compiling
describe Gisele2Gts, "on_task_def" do
before do
subject
subject.ith_state(0).initial!
end
subject do
code = <<-GIS.strip
task Main
Hello
end
GIS
Gisele2Gts.compile(code, :root => :task_def)
end
let :expected do
Gts.new do
add_state :kind =>:event, :initial => true
add_state :kind => :fork
add_state :kind => :event
add_state :kind => :listen, :accepting => true
add_state :kind => :event
add_state :kind => :end, :accepting => true
add_state :kind => :join, :accepting => true
add_state :kind => :event
add_state :kind => :end, :accepting => true
connect 0, 1, :symbol => :start, :event_args => [ "Main" ]
connect 1, 2, :symbol => :"(forked)"
connect 2, 3, :symbol => :start, :event_args => [ "Hello" ]
connect 3, 4, :symbol => :ended
connect 4, 5, :symbol => :end, :event_args => [ "Hello" ]
connect 5, 6, :symbol => :"(notify)"
connect 1, 6, :symbol => :"(wait)"
connect 6, 7, :symbol => nil
connect 7, 8, :symbol => :end, :event_args => [ "Main" ]
end
end
it 'generates an equivalent transition system' do
subject.bytecode_equivalent!(expected).should be_true
end
end
end
end
|
// This file is automatically generated.
package adila.db;
/*
* Motorola Cliq-XT
*
* DEVICE: zeppelin
* MODEL: MB501
*/
final class zeppelin_mb501 {
public static final String DATA = "Motorola|Cliq-XT|";
}
|
#include "transactiondesc.h"
#include "guiutil.h"
#include "lusocoinunits.h"
#include "main.h"
#include "wallet.h"
#include "db.h"
#include "ui_interface.h"
#include "base58.h"
#include <string>
QString TransactionDesc::FormatTxStatus(const CWalletTx& wtx)
{
if (!wtx.IsFinal())
{
if (wtx.nLockTime < LOCKTIME_THRESHOLD)
return tr("Open for %n more block(s)", "", wtx.nLockTime - nBestHeight + 1);
else
return tr("Open until %1").arg(GUIUtil::dateTimeStr(wtx.nLockTime));
}
else
{
int nDepth = wtx.GetDepthInMainChain();
if (GetAdjustedTime() - wtx.nTimeReceived > 2 * 60 && wtx.GetRequestCount() == 0)
return tr("%1/offline").arg(nDepth);
else if (nDepth < 6)
return tr("%1/unconfirmed").arg(nDepth);
else
return tr("%1 confirmations").arg(nDepth);
}
}
QString TransactionDesc::toHTML(CWallet *wallet, CWalletTx &wtx)
{
QString strHTML;
{
LOCK(wallet->cs_wallet);
strHTML.reserve(4000);
strHTML += "<html><font face='verdana, arial, helvetica, sans-serif'>";
int64 nTime = wtx.GetTxTime();
int64 nCredit = wtx.GetCredit();
int64 nDebit = wtx.GetDebit();
int64 nNet = nCredit - nDebit;
strHTML += "<b>" + tr("Status") + ":</b> " + FormatTxStatus(wtx);
int nRequests = wtx.GetRequestCount();
if (nRequests != -1)
{
if (nRequests == 0)
strHTML += tr(", has not been successfully broadcast yet");
else if (nRequests > 0)
strHTML += tr(", broadcast through %n node(s)", "", nRequests);
}
strHTML += "<br>";
strHTML += "<b>" + tr("Date") + ":</b> " + (nTime ? GUIUtil::dateTimeStr(nTime) : "") + "<br>";
// From
if (wtx.IsCoinBase())
{
strHTML += "<b>" + tr("Source") + ":</b> " + tr("Generated") + "<br>";
}
else if (wtx.mapValue.count("from") && !wtx.mapValue["from"].empty())
{
// Online transaction
strHTML += "<b>" + tr("From") + ":</b> " + GUIUtil::HtmlEscape(wtx.mapValue["from"]) + "<br>";
}
else
{
// Offline transaction
if (nNet > 0)
{
// Credit
BOOST_FOREACH(const CTxOut& txout, wtx.vout)
{
if (wallet->IsMine(txout))
{
CTxDestination address;
if (ExtractDestination(txout.scriptPubKey, address) && IsMine(*wallet, address))
{
if (wallet->mapAddressBook.count(address))
{
strHTML += "<b>" + tr("From") + ":</b> " + tr("unknown") + "<br>";
strHTML += "<b>" + tr("To") + ":</b> ";
strHTML += GUIUtil::HtmlEscape(CLusocoinAddress(address).ToString());
if (!wallet->mapAddressBook[address].empty())
strHTML += " (" + tr("own address") + ", " + tr("label") + ": " + GUIUtil::HtmlEscape(wallet->mapAddressBook[address]) + ")";
else
strHTML += " (" + tr("own address") + ")";
strHTML += "<br>";
}
}
break;
}
}
}
}
if (wtx.mapValue.count("to") && !wtx.mapValue["to"].empty())
{
// Online transaction
std::string strAddress = wtx.mapValue["to"];
strHTML += "<b>" + tr("To") + ":</b> ";
CTxDestination dest = CLusocoinAddress(strAddress).Get();
if (wallet->mapAddressBook.count(dest) && !wallet->mapAddressBook[dest].empty())
strHTML += GUIUtil::HtmlEscape(wallet->mapAddressBook[dest]) + " ";
strHTML += GUIUtil::HtmlEscape(strAddress) + "<br>";
}
// Amount
if (wtx.IsCoinBase() && nCredit == 0)
{
// Coinbase
int64 nUnmatured = 0;
BOOST_FOREACH(const CTxOut& txout, wtx.vout)
nUnmatured += wallet->GetCredit(txout);
strHTML += "<b>" + tr("Credit") + ":</b> ";
if (wtx.IsInMainChain())
strHTML += LusocoinUnits::formatWithUnit(LusocoinUnits::LUC, nUnmatured)+ " (" + tr("matures in %n more block(s)", "", wtx.GetBlocksToMaturity()) + ")";
else
strHTML += "(" + tr("not accepted") + ")";
strHTML += "<br>";
}
else if (nNet > 0)
{
// Credit
strHTML += "<b>" + tr("Credit") + ":</b> " + LusocoinUnits::formatWithUnit(LusocoinUnits::LUC, nNet) + "<br>";
}
else
{
bool fAllFromMe = true;
BOOST_FOREACH(const CTxIn& txin, wtx.vin)
fAllFromMe = fAllFromMe && wallet->IsMine(txin);
bool fAllToMe = true;
BOOST_FOREACH(const CTxOut& txout, wtx.vout)
fAllToMe = fAllToMe && wallet->IsMine(txout);
if (fAllFromMe)
{
// Debit
BOOST_FOREACH(const CTxOut& txout, wtx.vout)
{
if (wallet->IsMine(txout))
continue;
if (!wtx.mapValue.count("to") || wtx.mapValue["to"].empty())
{
// Offline transaction
CTxDestination address;
if (ExtractDestination(txout.scriptPubKey, address))
{
strHTML += "<b>" + tr("To") + ":</b> ";
if (wallet->mapAddressBook.count(address) && !wallet->mapAddressBook[address].empty())
strHTML += GUIUtil::HtmlEscape(wallet->mapAddressBook[address]) + " ";
strHTML += GUIUtil::HtmlEscape(CLusocoinAddress(address).ToString());
strHTML += "<br>";
}
}
strHTML += "<b>" + tr("Debit") + ":</b> " + LusocoinUnits::formatWithUnit(LusocoinUnits::LUC, -txout.nValue) + "<br>";
}
if (fAllToMe)
{
// Payment to self
int64 nChange = wtx.GetChange();
int64 nValue = nCredit - nChange;
strHTML += "<b>" + tr("Debit") + ":</b> " + LusocoinUnits::formatWithUnit(LusocoinUnits::LUC, -nValue) + "<br>";
strHTML += "<b>" + tr("Credit") + ":</b> " + LusocoinUnits::formatWithUnit(LusocoinUnits::LUC, nValue) + "<br>";
}
int64 nTxFee = nDebit - wtx.GetValueOut();
if (nTxFee > 0)
strHTML += "<b>" + tr("Transaction fee") + ":</b> " + LusocoinUnits::formatWithUnit(LusocoinUnits::LUC, -nTxFee) + "<br>";
}
else
{
// Mixed debit transaction
BOOST_FOREACH(const CTxIn& txin, wtx.vin)
if (wallet->IsMine(txin))
strHTML += "<b>" + tr("Debit") + ":</b> " + LusocoinUnits::formatWithUnit(LusocoinUnits::LUC, -wallet->GetDebit(txin)) + "<br>";
BOOST_FOREACH(const CTxOut& txout, wtx.vout)
if (wallet->IsMine(txout))
strHTML += "<b>" + tr("Credit") + ":</b> " + LusocoinUnits::formatWithUnit(LusocoinUnits::LUC, wallet->GetCredit(txout)) + "<br>";
}
}
strHTML += "<b>" + tr("Net amount") + ":</b> " + LusocoinUnits::formatWithUnit(LusocoinUnits::LUC, nNet, true) + "<br>";
// Message
if (wtx.mapValue.count("message") && !wtx.mapValue["message"].empty())
strHTML += "<br><b>" + tr("Message") + ":</b><br>" + GUIUtil::HtmlEscape(wtx.mapValue["message"], true) + "<br>";
if (wtx.mapValue.count("comment") && !wtx.mapValue["comment"].empty())
strHTML += "<br><b>" + tr("Comment") + ":</b><br>" + GUIUtil::HtmlEscape(wtx.mapValue["comment"], true) + "<br>";
strHTML += "<b>" + tr("Transaction ID") + ":</b> " + wtx.GetHash().ToString().c_str() + "<br>";
if (wtx.IsCoinBase())
strHTML += "<br>" + tr("Generated coins must mature 120 blocks before they can be spent. When you generated this block, it was broadcast to the network to be added to the block chain. If it fails to get into the chain, its state will change to \"not accepted\" and it won't be spendable. This may occasionally happen if another node generates a block within a few seconds of yours.") + "<br>";
// Debug view
if (fDebug)
{
strHTML += "<hr><br>" + tr("Debug information") + "<br><br>";
BOOST_FOREACH(const CTxIn& txin, wtx.vin)
if(wallet->IsMine(txin))
strHTML += "<b>" + tr("Debit") + ":</b> " + LusocoinUnits::formatWithUnit(LusocoinUnits::LUC, -wallet->GetDebit(txin)) + "<br>";
BOOST_FOREACH(const CTxOut& txout, wtx.vout)
if(wallet->IsMine(txout))
strHTML += "<b>" + tr("Credit") + ":</b> " + LusocoinUnits::formatWithUnit(LusocoinUnits::LUC, wallet->GetCredit(txout)) + "<br>";
strHTML += "<br><b>" + tr("Transaction") + ":</b><br>";
strHTML += GUIUtil::HtmlEscape(wtx.ToString(), true);
strHTML += "<br><b>" + tr("Inputs") + ":</b>";
strHTML += "<ul>";
{
LOCK(wallet->cs_wallet);
BOOST_FOREACH(const CTxIn& txin, wtx.vin)
{
COutPoint prevout = txin.prevout;
CCoins prev;
if(pcoinsTip->GetCoins(prevout.hash, prev))
{
if (prevout.n < prev.vout.size())
{
strHTML += "<li>";
const CTxOut &vout = prev.vout[prevout.n];
CTxDestination address;
if (ExtractDestination(vout.scriptPubKey, address))
{
if (wallet->mapAddressBook.count(address) && !wallet->mapAddressBook[address].empty())
strHTML += GUIUtil::HtmlEscape(wallet->mapAddressBook[address]) + " ";
strHTML += QString::fromStdString(CLusocoinAddress(address).ToString());
}
strHTML = strHTML + " " + tr("Amount") + "=" + LusocoinUnits::formatWithUnit(LusocoinUnits::LUC, vout.nValue);
strHTML = strHTML + " IsMine=" + (wallet->IsMine(vout) ? tr("true") : tr("false")) + "</li>";
}
}
}
}
strHTML += "</ul>";
}
strHTML += "</font></html>";
}
return strHTML;
}
|
LIBEVENT_VERSION="2.1.11-stable"
LIBEVENT_SHA256SUM="<SHA256-like>"
rm -fR libevent*
getpkg https://github.com/libevent/libevent/releases/download/release-${LIBEVENT_VERSION}/libevent-${LIBEVENT_VERSION}.tar.gz $LIBEVENT_SHA256SUM
tar zxvf libevent-${LIBEVENT_VERSION}.tar.gz
cd libevent-${LIBEVENT_VERSION}
./configure --prefix=$VENV
$PMAKE
make install
|
<?php
namespace Orinoco\Framework;
use RuntimeException;
class View
{
// layout name
public $layout;
// Orinoco\Framework\Http class
private $http;
// Orinoco\Framework\Route class
private $route;
// Passed controller's variables (to be used by view template)
private $variables;
// explicit view page
private $page_view;
/**
* Constructor
*
* @param Http object $http
* @param Route object $route
* @return void
*/
public function __construct(Http $http, Route $route)
{
$this->http = $http;
$this->route = $route;
}
/**
* Getter method
*
* @param Variable name $var_name
* @return Variable value
*/
public function __get($var_name)
{
if (isset($this->variables[$var_name])) {
return $this->variables[$var_name];
}
return false;
}
/**
* Set HTML layout
*
* @param Layout name
* @return void
*/
public function setLayout($layout_name)
{
$this->layout = $layout_name;
}
/**
* Set page/view template to use
*
* @param Page/view name Array or String
* @return void
*/
public function setPage($page_view)
{
// initialize default page view/template
$page = array(
'controller' => $this->route->getController(),
'action' => $this->route->getAction()
);
// check if passed parameter is an array
if (is_array($page_view)) {
if (isset($page_view['controller'])) {
$page['controller'] = $page_view['controller'];
}
if (isset($page_view['action'])) {
$page['action'] = $page_view['action'];
}
// string
} else if (is_string($page_view)) {
$exploded = explode('#', $page_view); // use '#' as separator (we can also use '/')
if (count($exploded) > 1) {
if (isset($exploded[0])) {
$page['controller'] = $exploded[0];
}
if (isset($exploded[1])) {
$page['action'] = $exploded[1];
}
} else {
$page['action'] = $page_view;
}
}
$this->page_view = (object) $page;
}
/**
* Render view template/page (including layout)
*
* @param $page_view Explicit page view/template file
* @param $obj_vars Variables to be passed to the layout and page template
* @return void
*/
public function render($page_view = null, $obj_vars = array())
{
if (isset($page_view)) {
$this->setPage($page_view);
}
// store variables (to be passed to the layout and page template)
// accessible via '__get' method
$this->variables = $obj_vars;
// check if layout is defined
if(isset($this->layout)) {
$layout_file = <API key> . str_replace(PHP_FILE_EXTENSION, '', $this->layout) . PHP_FILE_EXTENSION;
if (!file_exists($layout_file)) {
$this->http->setHeader($this->http->getValue('SERVER_PROTOCOL') . ' 500 Internal Server Error', true, 500);
if (DEVELOPMENT) {
throw new RuntimeException('It seems that "' . str_replace(ROOT_DIR, '', $layout_file) . '" does not exists.');
} else {
$this->renderErrorPage(500);
}
} else {
require $layout_file;
}
} else {
$default_layout = $this->getDefaultLayout();
if (file_exists($default_layout)) {
require $default_layout;
} else {
$this->http->setHeader($this->http->getValue('SERVER_PROTOCOL') . ' 500 Internal Server Error', true, 500);
if (DEVELOPMENT) {
throw new RuntimeException('It seems that "' . str_replace(ROOT_DIR, '', $default_layout) . '" does not exists.');
} else {
$this->renderErrorPage(500);
}
}
}
}
/**
* Render error page
*
* @param Error code (e.g. 404, 500, etc)
* @return void
*/
public function renderErrorPage($error_code = null)
{
if (defined('ERROR_' . $error_code . '_PAGE')) {
$error_page = constant('ERROR_' . $error_code . '_PAGE');
$error_page_file = <API key> . str_replace(PHP_FILE_EXTENSION, '', $error_page) . PHP_FILE_EXTENSION;
if (file_exists($error_page_file)) {
require $error_page_file;
} else {
// error page not found? show this error message
$this->http->setHeader($this->http->getValue('SERVER_PROTOCOL') . ' 500 Internal Server Error', true, 500);
$this->setContent('500 - Internal Server Error (Unable to render ' . $error_code . ' error page)');
}
} else {
// error page not found? show this error message
$this->http->setHeader($this->http->getValue('SERVER_PROTOCOL') . ' 500 Internal Server Error', true, 500);
$this->setContent('500 - Internal Server Error (Unable to render ' . $error_code . ' error page)');
}
}
/**
* Get action (presentation) content
*
* @return bool; whether or not content file exists
*/
public function getContent()
{
// check if page view is specified or not
if (!isset($this->page_view)) {
$content_view = <API key> . $this->route->getController() . '/' . $this->route->getAction() . PHP_FILE_EXTENSION;
} else {
$content_view = <API key> . $this->page_view->controller . '/' . $this->page_view->action . PHP_FILE_EXTENSION;
}
/**
* @todo Should we render an error page, saying something like "the page template aren't found"?
*/
if(!file_exists($content_view)) {
// No verbose
return false;
}
require $content_view;
}
/**
* Get partial (presentation) content
*
* @param String Partial name/path $partial_name
* @return bool; whether or not partial file exists
*/
public function getPartial($partial_name)
{
$partial_view = <API key> . $partial_name . PHP_FILE_EXTENSION;
if(!file_exists($partial_view)) {
// No verbose
return false;
}
require $partial_view;
}
/**
* Clear output buffer content
*
* @return void
*/
public function clearContent()
{
ob_clean();
}
/**
* Print out passed content
*
* @return void
*/
public function setContent($content = null)
{
print($content);
}
/**
* Flush output buffer content
*
* @return void
*/
public function flush()
{
ob_flush();
}
/**
* Return the default layout path
*
* @return string
*/
private function getDefaultLayout()
{
return <API key> . DEFAULT_LAYOUT . PHP_FILE_EXTENSION;
}
/**
* Construct JSON string (and also set HTTP header as 'application/json')
*
* @param $data Array
* @return void
*/
public function renderJSON($data = array())
{
$json = json_encode($data);
$this->http->setHeader(array(
'Content-Length' => strlen($json),
'Content-type' => 'application/json;'
));
$this->setContent($json);
}
/**
* Redirect using header
*
* @param string|array $mixed
* @param Use 'refresh' instead of 'location' $use_refresh
* @param Time to refresh $refresh_time
* @return void
*/
public function redirect($mixed, $use_refresh = false, $refresh_time = 3)
{
$url = null;
if (is_string($mixed)) {
$url = trim($mixed);
} else if (is_array($mixed)) {
$controller = $this->route->getController();
$action = null;
if (isset($mixed['controller'])) {
$controller = trim($mixed['controller']);
}
$url = '/' . $controller;
if (isset($mixed['action'])) {
$action = trim($mixed['action']);
}
if (isset($action)) {
$url .= '/' . $action;
}
if (isset($mixed['query'])) {
$query = '?';
foreach ($mixed['query'] as $k => $v) {
$query .= $k . '=' . urlencode($v) . '&';
}
$query[strlen($query) - 1] = '';
$query = trim($query);
$url .= $query;
}
}
if (!$use_refresh) {
$this->http->setHeader('Location: ' . $url);
} else {
$this->http->setHeader('refresh:' . $refresh_time . ';url=' . $url);
}
// exit normally
exit(0);
}
}
|
/*
0. Normalize
1. Icons
2. General
3. Utilities
4. General
5. Single Post
6. Tag Archive
7. Third Party Elements
8. Pagination
9. Footer
10. Media Queries (Tablet)
11. Media Queries (Mobile)
12. Animations
*/
article, aside, details,
figcaption, figure,
footer, header, hgroup,
main, nav, section,
summary { display: block; }
audio, canvas, video { display: inline-block; }
audio:not([controls]) { display: none; height: 0; }
[hidden], template { display: none; }
html {
font-family: sans-serif;
-ms-text-size-adjust: 100%;
-<API key>: 100%;
}
body { margin: 0; }
a { background: transparent; }
a:focus { outline: thin dotted; }
a:active, a:hover { outline: 0; }
h1 { font-size: 2em; margin: 0.67em 0; }
abbr[title] { border-bottom: 1px dotted; }
b, strong { font-weight: 700; }
dfn { font-style: italic; }
hr {
-moz-box-sizing: content-box;
box-sizing: content-box;
height: 0;
}
mark { background: #FF0; color: #000; }
code, kbd, pre,
samp { font-family: monospace, serif; font-size: 1em; }
pre { white-space: pre-wrap; }
q { quotes: "\201C" "\201D" "\2018" "\2019"; }
small { font-size: 80%; }
sub, sup {
font-size: 75%;
line-height: 0;
position: relative;
vertical-align: baseline;
}
sup { top: -0.5em; }
sub { bottom: -0.25em; }
img { border: 0; }
svg:not(:root) { overflow: hidden; }
figure { margin: 0; }
fieldset {
border: 1px solid #c0c0c0;
margin: 0 2px;
padding: 0.35em 0.625em 0.75em;
}
legend { border: 0; padding: 0; }
button, input, select,
textarea { font-family: inherit; font-size: 100%; margin: 0; }
button, input { line-height: normal; }
button, select { text-transform: none; }
button, html input[type="button"],
input[type="reset"], input[type="submit"] {
-webkit-appearance: button;
cursor: pointer;
}
button[disabled], html input[disabled] { cursor: default; }
input[type="checkbox"],
input[type="radio"] { box-sizing: border-box; padding: 0; }
input[type="search"] {
-webkit-appearance: textfield;
-moz-box-sizing: content-box;
-webkit-box-sizing: content-box;
box-sizing: content-box;
}
input[type="search"]::-<API key>,
input[type="search"]::-<API key> { -webkit-appearance: none; }
button::-moz-focus-inner,
input::-moz-focus-inner { border: 0; padding: 0; }
textarea { overflow: auto; vertical-align: top; }
table { border-collapse: collapse; border-spacing: 0; }
/* Import the font file with the icons in it */
@font-face {
font-family: "casper-icons";
src:url("../fonts/casper-icons.eot");
src:url("../fonts/casper-icons.eot?#iefix") format("embedded-opentype"),
url("../fonts/casper-icons.woff") format("woff"),
url("../fonts/casper-icons.ttf") format("truetype"),
url("../fonts/casper-icons.svg#icons") format("svg");
font-weight: normal;
font-style: normal;
}
/* Apply these base styles to all icons */
[class^="icon-"]:before, [class*=" icon-"]:before {
font-family: "casper-icons", "Open Sans", sans-serif;
speak: none;
font-style: normal;
font-weight: normal;
font-variant: normal;
text-transform: none;
line-height: 1;
text-decoration: none !important;
-<API key>: antialiased;
-<API key>: grayscale;
}
.icon-ghost:before {
content: "\f600";
}
.icon-feed:before {
content: "\f601";
}
.icon-twitter:before {
content: "\f602";
font-size: 1.1em;
}
.icon-google-plus:before {
content: "\f603";
}
.icon-facebook:before {
content: "\f604";
}
.icon-arrow-left:before {
content: "\f605";
}
.icon-stats:before {
content: "\f606";
}
.icon-location:before {
content: "\f607";
margin-left: -3px; /* Tracking fix */
}
.icon-link:before {
content: "\f608";
}
html {
height: 100%;
max-height: 100%;
font-size: 62.5%;
-<API key>: rgba(0, 0, 0, 0);
}
body {
height: 100%;
max-height: 100%;
font-family: "Merriweather", serif;
letter-spacing: 0.01rem;
font-size: 1.8rem;
line-height: 1.75em;
color: #3A4145;
-<API key>: 'kern' 1;
-<API key>: 'kern' 1;
-<API key>: 'kern' 1;
}
::-moz-selection {
background: #D6EDFF;
}
::selection {
background: #D6EDFF;
}
h1, h2, h3,
h4, h5, h6 {
-<API key>: 'dlig' 1, 'liga' 1, 'lnum' 1, 'kern' 1;
-<API key>: 'dlig' 1, 'liga' 1, 'lnum' 1, 'kern' 1;
-<API key>: 'dlig' 1, 'liga' 1, 'lnum' 1, 'kern' 1;
color: #2E2E2E;
line-height: 1.15em;
margin: 0 0 0.4em 0;
font-family: "Open Sans", sans-serif;
}
h1 {
font-size: 5rem;
letter-spacing: -2px;
text-indent: -3px;
}
h2 {
font-size: 3.6rem;
letter-spacing: -1px;
}
h3 {
font-size: 3rem;
}
h4 {
font-size: 2.5rem;
}
h5 {
font-size: 2rem;
}
h6 {
font-size: 2rem;
}
a {
color: #4A4A4A;
transition: color ease 0.3s;
}
a:hover {
color: #111;
}
p, ul, ol, dl {
-<API key>: 'liga' 1, 'onum' 1, 'kern' 1;
-<API key>: 'liga' 1, 'onum' 1, 'kern' 1;
-<API key>: 'liga' 1, 'onum' 1, 'kern' 1;
margin: 0 0 1.75em 0;
}
ol, ul {
padding-left: 3rem;
}
ol ol, ul ul,
ul ol, ol ul {
margin: 0 0 0.4em 0;
padding-left: 2em;
}
dl dt {
float: left;
width: 180px;
overflow: hidden;
clear: left;
text-align: right;
text-overflow: ellipsis;
white-space: nowrap;
font-weight: 700;
margin-bottom: 1em;
}
dl dd {
margin-left: 200px;
margin-bottom: 1em
}
li {
margin: 0.4em 0;
}
li li {
margin: 0;
}
hr {
display: block;
height: 1px;
border: 0;
border-top: #EFEFEF 1px solid;
margin: 3.2em 0;
padding: 0;
}
blockquote {
-moz-box-sizing: border-box;
box-sizing: border-box;
margin: 1.75em 0 1.75em -2.2em;
padding: 0 0 0 1.75em;
border-left: #4A4A4A 0.4em solid;
}
blockquote p {
margin: 0.8em 0;
font-style: italic;
}
blockquote small {
display: inline-block;
margin: 0.8em 0 0.8em 1.5em;
font-size: 0.9em;
color: #CCC;
}
blockquote small:before { content: "\2014 \00A0"; }
blockquote cite {
font-weight: 700;
}
blockquote cite a { font-weight: normal; }
mark {
background-color: #FFC336;
}
code, tt {
padding: 1px 3px;
font-family: Inconsolata, monospace, sans-serif;
font-size: 0.85em;
white-space: pre-wrap;
border: #E3EDF3 1px solid;
background: #F7FAFB;
border-radius: 2px;
}
pre {
-moz-box-sizing: border-box;
box-sizing: border-box;
margin: 0 0 1.75em 0;
border: #E3EDF3 1px solid;
width: 100%;
padding: 10px;
font-family: Inconsolata, monospace, sans-serif;
font-size: 0.9em;
white-space: pre;
overflow: auto;
background: #F7FAFB;
border-radius: 3px;
}
pre code, tt {
font-size: inherit;
white-space: -moz-pre-wrap;
white-space: pre-wrap;
background: transparent;
border: none;
padding: 0;
}
kbd {
display: inline-block;
margin-bottom: 0.4em;
padding: 1px 8px;
border: #CCC 1px solid;
color: #666;
text-shadow: #FFF 0 1px 0;
font-size: 0.9em;
font-weight: 700;
background: #F4F4F4;
border-radius: 4px;
box-shadow:
0 1px 0 rgba(0, 0, 0, 0.2),
0 1px 0 0 #fff inset;
}
table {
-moz-box-sizing: border-box;
box-sizing: border-box;
margin: 1.75em 0;
width: 100%;
max-width: 100%;
background-color: transparent;
}
table th,
table td {
padding: 8px;
line-height: 20px;
text-align: left;
vertical-align: top;
border-top: #EFEFEF 1px solid;
}
table th { color: #000; }
table caption + thead tr:first-child th,
table caption + thead tr:first-child td,
table colgroup + thead tr:first-child th,
table colgroup + thead tr:first-child td,
table thead:first-child tr:first-child th,
table thead:first-child tr:first-child td {
border-top: 0;
}
table tbody + tbody { border-top: #EFEFEF 2px solid; }
table table table { background-color: #FFF; }
table tbody > tr:nth-child(odd) > td,
table tbody > tr:nth-child(odd) > th {
background-color: #F6F6F6;
}
table.plain tbody > tr:nth-child(odd) > td,
table.plain tbody > tr:nth-child(odd) > th {
background: transparent;
}
iframe, .<API key> {
display: block;
margin: 1.75em 0;
}
/* When a video is inside the fitvids wrapper, drop the
margin on the iframe, cause it breaks stuff. */
.<API key> iframe {
margin: 0;
}
/* Clears shit */
.clearfix:before,
.clearfix:after {
content: " ";
display: table;
}
.clearfix:after { clear: both; }
.clearfix { *zoom: 1; }
/* Hides shit */
.hidden {
text-indent: -9999px;
visibility: hidden;
display: none;
}
/* Creates a responsive wrapper that makes our content scale nicely */
.inner {
position: relative;
width: 80%;
max-width: 710px;
margin: 0 auto;
}
/* Centres vertically yo. (IE8+) */
.vertical {
display: table-cell;
vertical-align: middle;
}
/* Big cover image on the home page */
.main-header {
position: relative;
display: table;
width: 100%;
height: 100%;
margin-bottom: 5rem;
text-align: center;
background: #222 no-repeat center center;
background-size: cover;
overflow: hidden;
}
.main-header .inner {
width: 80%;
}
.main-nav {
position: relative;
padding: 35px 40px;
margin: 0 0 30px 0;
}
.main-nav a {
text-decoration: none;
font-family: 'Open Sans', sans-serif;
}
/* Create a bouncing scroll-down arrow on homepage with cover image */
.scroll-down {
display: block;
position: absolute;
z-index: 100;
bottom: 45px;
left: 50%;
margin-left: -16px;
width: 34px;
height: 34px;
font-size: 34px;
text-align: center;
text-decoration: none;
color: rgba(255,255,255,0.7);
-webkit-transform: rotate(-90deg);
transform: rotate(-90deg);
-webkit-animation: bounce 4s 2s infinite;
animation: bounce 4s 2s infinite;
}
/* Stop it bouncing and increase contrast when hovered */
.scroll-down:hover {
color: #fff;
-webkit-animation: none;
animation: none;
}
/* Put a semi-opaque radial gradient behind the icon to make it more visible
on photos which happen to have a light background. */
.home-template .main-header:after {
display: block;
content: " ";
width: 150px;
height: 130px;
border-radius: 100%;
position: absolute;
bottom: 0;
left: 50%;
margin-left: -75px;
background: -moz-radial-gradient(center, ellipse cover, rgba(0,0,0,0.15) 0%, rgba(0,0,0,0) 70%, rgba(0,0,0,0) 100%);
background: -webkit-gradient(radial, center center, 0px, center center, 100%, color-stop(0%,rgba(0,0,0,0.15)), color-stop(70%,rgba(0,0,0,0)), color-stop(100%,rgba(0,0,0,0)));
background: -<API key>(center, ellipse cover, rgba(0,0,0,0.15) 0%,rgba(0,0,0,0) 70%,rgba(0,0,0,0) 100%);
background: radial-gradient(ellipse at center, rgba(0,0,0,0.15) 0%,rgba(0,0,0,0) 70%,rgba(0,0,0,0) 100%);
}
/* Hide when there's no cover image or on page2+ */
.no-cover .scroll-down,
.no-cover.main-header:after,
.archive-template .scroll-down,
.archive-template .main-header:after {
display: none
}
/* Appears in the top right corner of your home page */
.blog-logo {
display: block;
float: left;
background: none !important;
border: none !important;
}
.blog-logo img {
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
display: block;
height: 38px;
padding: 1px 0 5px 0;
width: auto;
}
.back-button {
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
display: inline-block;
float: left;
height: 38px;
padding: 0 15px 0 10px;
border: transparent 1px solid;
color: #9EABB3;
text-align: center;
font-size: 12px;
text-transform: uppercase;
line-height: 35px;
border-radius: 3px;
background: rgba(0,0,0,0.1);
transition: all ease 0.3s;
}
.back-button:before {
position: relative;
bottom: -2px;
font-size: 13px;
line-height: 0;
margin-right: 8px;
}
.subscribe-button {
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
display: inline-block;
float: right;
height: 38px;
padding: 0 20px;
border: transparent 1px solid;
color: #9EABB3;
text-align: center;
font-size: 12px;
text-transform: uppercase;
line-height: 35px;
white-space: nowrap;
border-radius: 3px;
background: rgba(0,0,0,0.1);
transition: all ease 0.3s;
}
.subscribe-button:before {
font-size: 9px;
margin-right: 6px;
}
/* Special styles when overlaid on an image*/
.main-nav.overlay {
position: absolute;
top: 0;
left: 0;
right: 0;
height: 70px;
border: none;
background: -moz-linear-gradient(top, rgba(0,0,0,0.2) 0%, rgba(0,0,0,0) 100%);
background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,rgba(0,0,0,0.2)), color-stop(100%,rgba(0,0,0,0)));
background: -<API key>(top, rgba(0,0,0,0.2) 0%,rgba(0,0,0,0) 100%);
background: linear-gradient(to bottom, rgba(0,0,0,0.2) 0%,rgba(0,0,0,0) 100%);
}
.no-cover .main-nav.overlay,
.no-cover .back-button,
.no-cover .subscribe-button {
background: none;
}
.main-nav.overlay a {
color: #fff;
}
.main-nav.overlay .back-button,
.main-nav.overlay .subscribe-button {
border-color: rgba(255,255,255,0.6);
}
.main-nav.overlay a:hover {
color: #222;
border-color: #fff;
background: #fff;
transition: all 0.1s ease;
}
/* Add a border to the buttons on hover */
.back-button:hover,
.subscribe-button:hover {
border-color: #bfc8cd;
color: #9EABB3;
}
/* The details of your blog. Defined in ghost/settings/ */
.page-title {
margin: 10px 0 10px 0;
font-size: 5rem;
letter-spacing: -1px;
font-weight: 700;
font-family: "Open Sans", sans-serif;
color: #fff;
}
.page-description {
margin: 0;
font-size: 2rem;
line-height: 1.5em;
font-weight: 400;
font-family: "Merriweather", serif;
letter-spacing: 0.01rem;
color: rgba(255,255,255,0.8);
}
.no-cover.main-header {
min-height: 160px;
max-height: 40%;
background: #f5f8fa;
}
.no-cover .page-title {
color: rgba(0,0,0,0.8);
}
.no-cover .page-description {
color: rgba(0,0,0,0.5);
}
.no-cover .main-nav.overlay .back-button,
.no-cover .main-nav.overlay .subscribe-button {
color: rgba(0,0,0,0.4);
border-color: rgba(0,0,0,0.3);
}
/* Add subtle load-in animation for content on the home page */
.home-template .page-title {
-webkit-animation: fade-in-down 0.6s;
animation: fade-in-down 0.6s;
-<API key>: 0.2s;
animation-delay: 0.2s;
}
.home-template .page-description {
-webkit-animation: fade-in-down 0.9s;
animation: fade-in-down 0.9s;
-<API key>: 0.1s;
animation-delay: 0.1s;
}
/* Every post, on every page, gets this style on its <article> tag */
.post {
position: relative;
width: 80%;
max-width: 710px;
margin: 4rem auto;
padding-bottom: 4rem;
word-break: break-word;
hyphens: auto;
}
body:not(.post-template) .post-title {
font-size: 3.6rem;
}
.post-title a {
text-decoration: none;
}
.post-excerpt p {
margin: 0;
font-size: 0.9em;
line-height: 1.7em;
}
.read-more {
text-decoration: none;
}
.post-meta {
display: block;
margin: 1.75rem 0 0 0;
font-family: "Open Sans", sans-serif;
font-size: 1.5rem;
line-height: 2.2rem;
color: #9EABB3;
}
.author-thumb {
width: 24px;
height: 24px;
float: left;
margin-right: 9px;
border-radius: 100%;
}
.post-meta a {
color: #9EABB3;
text-decoration: none;
}
.post-meta a:hover {
text-decoration: underline;
}
.user-meta {
position: relative;
padding: 0.3rem 40px 0 100px;
min-height: 77px;
}
.post-date {
display: inline-block;
margin-left: 8px;
padding-left: 12px;
border-left: #d5dbde 1px solid;
text-transform: uppercase;
font-size: 1.3rem;
white-space: nowrap;
}
.user-image {
position: absolute;
top: 0;
left: 0;
}
.user-name {
display: block;
font-weight: 700;
}
.user-bio {
display: block;
max-width: 440px;
font-size: 1.4rem;
line-height: 1.5em;
}
.publish-meta {
position: absolute;
top: 0;
right: 0;
padding: 4.3rem 0 4rem 0;
text-align: right;
}
.publish-heading {
display: block;
font-weight: 700;
}
.publish-date {
display: block;
font-size: 1.4rem;
line-height: 1.5em;
}
.post-template .post-header {
margin-bottom: 3.4rem;
}
.post-template .post-title {
margin-bottom: 0;
}
.post-template .post-meta {
margin: 0;
}
.post-template .post-date {
padding: 0;
margin: 0;
border: none;
}
/* Stop .full-img from creating horizontal scroll - slight hack due to
imperfections with browser width % calculations and rounding */
.post-template .content {
overflow: hidden;
}
/* Tweak the .post wrapper style */
.post-template .post {
margin-top: 0;
border-bottom: none;
padding-bottom: 0;
}
/* Kill that stylish little circle that was on the border, too */
.post-template .post:after {
display: none;
}
/* Keep images centred and within the bounds of the post-width */
.post-content img {
display: block;
max-width: 100%;
height: auto;
margin: 0 auto;
padding: 0.6em 0;
}
/* Break out larger images to be wider than the main text column
the class is applied with jQuery */
.post-content .full-img {
width: 126%;
max-width: none;
margin: 0 -13%;
}
/* The author credit area after the post */
.author-footer {
position: relative;
margin: 6rem 0;
padding: 4rem 4rem 2rem 4rem;
border-top: #EBF2F6 1px solid;
word-break: break-word;
hyphens: auto;
}
.post-footer h4,
.author-footer h4 {
font-size: 1.8rem;
margin: 0;
}
.author-footer p {
margin: 1rem 0;
font-size: 1.4rem;
line-height: 1.75em;
}
/* list of author links - location / url */
.author-meta {
padding: 0;
margin: 0;
list-style: none;
font-size: 1.4rem;
line-height: 1;
font-style: italic;
color: #9EABB3;
}
.author-meta a {
color: #9EABB3;
}
.author-meta a:hover {
color: #111;
}
/* Create some space to the right for the share links */
.author-footer .author {
float: left;
}
.author-footer h4 a {
color: #2e2e2e;
text-decoration: none;
}
.author-footer h4 a:hover {
text-decoration: underline;
}
/* Drop the share links in the space to the right.
Doing it like this means it's easier for the author bio
to be flexible at smaller screen sizes while the share
links remain at a fixed width the whole time */
.author-footer .connect {
position: absolute;
top: 4rem;
right: 0;
width: 140px;
}
.post-footer .share a,
.author-footer .connect a {
font-size: 1.8rem;
display: inline-block;
margin: 1rem 1.6rem 1.6rem 0;
color: #999;
text-decoration: none;
}
.post-footer .share a:hover,
.author-footer .connect a:hover {
color: #111;
}
.social {
float: right;
}
.social .icon {
margin: 1rem 1.6rem 1.6rem 0;
color: #999;
text-decoration: none;
}
.social .icon:hover {
color: #111;
}
.share {
float: left;
}
/* The subscribe icon on the footer */
.subscribe {
width: 28px;
height: 28px;
position: absolute;
top: -14px;
left: 50%;
margin-left: -15px;
border: #EBF2F6 1px solid;
text-align: center;
line-height: 2.4rem;
border-radius: 50px;
background: #FFF;
transition: box-shadow 0.5s;
}
/* The RSS icon, inserted via icon font */
.subscribe:before {
color: #D2DEE3;
font-size: 10px;
position: absolute;
top: 2px;
left: 9px;
font-weight: 700;
transition: color 0.5s ease;
}
/* Add a box shadow to on hover */
.subscribe:hover {
box-shadow: rgba(0,0,0,0.05) 0 0 0 3px;
transition: box-shadow 0.25s;
}
.subscribe:hover:before {
color: #50585D;
}
/* CSS tooltip saying "Subscribe!" - initially hidden */
.tooltip {
opacity: 0;
display: block;
width: 53px;
padding: 4px 8px 5px 8px;
position:absolute;
top: -23px;
left: -21px;
color: rgba(255,255,255,0.9);
font-size: 1.1rem;
line-height: 1em;
text-align: center;
background: #50585D;
border-radius: 20px;
box-shadow: 0 1px 4px rgba(0,0,0,0.1);
transition: opacity 0.3s ease, top 0.3s ease;
}
/* The little chiclet arrow under the tooltip, pointing down */
.tooltip:after {
content: " ";
border-width: 5px 5px 0 5px;
border-style: solid;
border-color: #50585D transparent;
display: block;
position: absolute;
bottom: -4px;
left: 50%;
margin-left: -5px;
z-index: 220;
width: 0;
}
/* On hover, show the tooltip! */
.subscribe:hover .tooltip {
opacity: 1;
top: -33px;
}
.post-head.main-header {
height: 65%;
min-height: 180px;
}
.no-cover.post-head.main-header {
height: 85px;
min-height: 0;
margin-bottom: 0;
background: transparent;
}
.tag-head.main-header {
height: 40%;
min-height: 180px;
}
.author-head.main-header {
height: 40%;
min-height: 180px;
}
.no-cover.author-head.main-header {
height: 10%;
min-height: 100px;
background: transparent;
}
.author-profile {
padding: 0 15px 5rem 15px;
border-bottom: #EBF2F6 1px solid;
text-align: center;
}
/* Add a little circle in the middle of the border-bottom */
.author-profile:after {
display: block;
content: "";
width: 7px;
height: 7px;
border: #E7EEF2 1px solid;
position: absolute;
bottom: -5px;
left: 50%;
margin-left: -5px;
background: #FFF;
-<API key>: 100%;
-moz-border-radius: 100%;
border-radius: 100%;
box-shadow: #FFF 0 0 0 5px;
}
.author-image {
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
display: block;
position: absolute;
top: -40px;
left: 50%;
margin-left: -40px;
width: 80px;
height: 80px;
border-radius: 100%;
overflow: hidden;
padding: 6px;
background: #fff;
z-index: 2;
box-shadow: #E7EEF2 0 0 0 1px;
}
.author-image .img {
position: relative;
display: block;
width: 100%;
height: 100%;
background-size: cover;
background-position: center center;
border-radius: 100%;
}
.author-profile .author-image {
position: relative;
left: auto;
top: auto;
width: 120px;
height: 120px;
padding: 3px;
margin: -100px auto 0 auto;
box-shadow: none;
}
.author-title {
margin: 1.5rem 0 1rem;
}
.author-bio {
font-size: 1.8rem;
line-height: 1.5em;
font-weight: 200;
color: #50585D;
letter-spacing: 0;
text-indent: 0;
}
.author-meta {
margin: 1.6rem 0;
}
/* Location, website, and link */
.author-profile .author-meta {
margin: 2rem 0;
font-family: "Merriweather", serif;
letter-spacing: 0.01rem;
font-size: 1.7rem;
}
.author-meta span {
display: inline-block;
margin: 0 2rem 1rem 0;
word-wrap: break-word;
}
.author-meta a {
text-decoration: none;
}
/* Turn off meta for page2+ to make room for extra
pagination prev/next links */
.archive-template .author-profile .author-meta {
display: none;
}
/* Github */
.gist table {
margin: 0;
font-size: 1.4rem;
}
.gist .line-number {
min-width: 25px;
font-size: 1.1rem;
}
/* The main wrapper for our pagination links */
.pagination {
position: relative;
width: 80%;
max-width: 710px;
margin: 4rem auto;
font-family: "Open Sans", sans-serif;
font-size: 1.3rem;
color: #9EABB3;
text-align: center;
}
.pagination a {
color: #9EABB3;
transition: all 0.2s ease;
}
/* Push the previous/next links out to the left/right */
.older-posts,
.newer-posts {
position: absolute;
display: inline-block;
padding: 0 15px;
border: #bfc8cd 1px solid;
text-decoration: none;
border-radius: 4px;
transition: border ease 0.3s;
}
.older-posts {
right: 0;
}
.page-number {
display: inline-block;
padding: 2px 0;
min-width: 100px;
}
.newer-posts {
left: 0;
}
.older-posts:hover,
.newer-posts:hover {
color: #889093;
border-color: #98a0a4;
}
.extra-pagination {
display: none;
border-bottom: #EBF2F6 1px solid;
}
.extra-pagination:after {
display: block;
content: "";
width: 7px;
height: 7px;
border: #E7EEF2 1px solid;
position: absolute;
bottom: -5px;
left: 50%;
margin-left: -5px;
background: #FFF;
-<API key>: 100%;
-moz-border-radius: 100%;
border-radius: 100%;
box-shadow: #FFF 0 0 0 5px;
}
.extra-pagination .pagination {
width: auto;
}
/* On page2+ make all the headers smaller */
.archive-template .main-header {
max-height: 30%;
}
/* On page2+ show extra pagination controls at the top of post list */
.archive-template .extra-pagination {
display: block;
}
.site-footer {
position: relative;
margin: 8rem 0 0 0;
padding: 0.5rem 15px;
border-top: #EBF2F6 1px solid;
font-family: "Open Sans", sans-serif;
font-size: 1rem;
line-height: 1.75em;
color: #BBC7CC;
}
.site-footer a {
color: #BBC7CC;
text-decoration: none;
font-weight: bold;
}
.site-footer a:hover {
color: #50585D;
}
.poweredby {
display: block;
width: 45%;
float: right;
text-align: right;
}
.copyright {
display: block;
width: 45%;
float: left;
}
@media only screen and (max-width: 900px) {
.main-nav {
padding: 15px;
}
blockquote {
margin-left: 0;
}
.main-header {
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
height: auto;
min-height: 240px;
height: 60%;
padding: 15% 0;
}
.scroll-down,
.home-template .main-header:after { display: none; }
.archive-template .main-header {
min-height: 180px;
padding: 10% 0;
}
.blog-logo img {
padding: 4px 0;
}
.page-title {
font-size: 4rem;
letter-spacing: -1px;
}
.page-description {
font-size: 1.8rem;
line-height: 1.5em;
}
.post {
font-size: 0.95em
}
body:not(.post-template) .post-title {
font-size: 3.2rem;
}
hr {
margin: 2.4em 0;
}
ol, ul {
padding-left: 2em;
}
h1 {
font-size: 4.5rem;
text-indent: -2px;
}
h2 {
font-size: 3.6rem;
}
h3 {
font-size: 3.1rem;
}
h4 {
font-size: 2.5rem;
}
h5 {
font-size: 2.2rem;
}
h6 {
font-size: 1.8rem;
}
.author-profile {
padding-bottom: 4rem;
}
.author-profile .author-bio {
font-size: 1.6rem;
}
.author-meta span {
display: block;
margin: 1.5rem 0;
}
.author-profile .author-meta span {
font-size: 1.6rem;
}
.post-head.main-header {
height:45%;
}
.tag-head.main-header,
.author-head.main-header {
height: 30%;
}
.no-cover.post-head.main-header {
height: 55px;
padding: 0;
}
.no-cover.author-head.main-header {
padding: 0;
}
}
@media only screen and (max-width: 500px) {
.main-header {
margin-bottom: 15px;
height: 40%;
}
.no-cover.main-header {
height: 30%;
}
.archive-template .main-header {
max-height: 20%;
min-height: 160px;
padding: 10% 0;
}
.main-nav {
padding: 0;
margin-bottom: 2rem;
border-bottom: #e0e4e7 1px solid;
}
.blog-logo {
padding: 10px 10px;
}
.blog-logo img {
height: 26px;
}
.back-button,
.subscribe-button {
height: 44px;
line-height: 41px;
border-radius: 0;
color: #2e2e2e;
background: transparent;
}
.back-button:hover,
.subscribe-button:hover {
border-color: #ebeef0;
color: #2e2e2e;
background: #ebeef0;
}
.back-button {
padding: 0 15px 0 10px;
}
.subscribe-button {
padding: 0 12px;
}
.main-nav.overlay a:hover {
color: #fff;
border-color: transparent;
background: transparent;
}
.no-cover .main-nav.overlay {
background: none;
}
.no-cover .main-nav.overlay .back-button,
.no-cover .main-nav.overlay .subscribe-button {
border: none;
}
.main-nav.overlay .back-button,
.main-nav.overlay .subscribe-button {
border-color: transparent;
}
.blog-logo img {
max-height: 80px;
}
.inner,
.pagination {
width: auto;
margin: 2rem auto;
}
.post {
width: auto;
margin-top: 2rem;
margin-bottom: 2rem;
margin-left: 16px;
margin-right: 16px;
padding-bottom: 2rem;
line-height: 1.65em;
}
.post-date {
display: none;
}
.post-template .post-header {
margin-bottom: 2rem;
}
.post-template .post-date {
display: inline-block;
}
hr {
margin: 1.75em 0;
}
p, ul, ol, dl {
font-size: 0.95em;
margin: 0 0 2.5rem 0;
}
.page-title {
font-size: 3rem;
}
.post-excerpt p {
font-size: 0.85em;
}
.page-description {
font-size: 1.6rem;
}
h1, h2, h3,
h4, h5, h6 {
margin: 0 0 0.3em 0;
}
h1 {
font-size: 2.8rem;
letter-spacing: -1px;
}
h2 {
font-size: 2.4rem;
letter-spacing: 0;
}
h3 {
font-size: 2.1rem;
}
h4 {
font-size: 1.9rem;
}
h5 {
font-size: 1.8rem;
}
h6 {
font-size: 1.8rem;
}
body:not(.post-template) .post-title {
font-size: 2.5rem;
}
.post-template .post {
padding-bottom: 0;
margin-bottom: 0;
}
.post-template .site-footer {
margin-top: 0;
}
.post-content img {
padding: 0;
}
.post-content .full-img {
width: auto;
width: calc(100% + 32px); /* expand with to image + margins */
margin: 0 -16px; /* get rid of margins */
min-width: 0;
max-width: 112%; /* fallback when calc doesn't work */
}
.post-meta {
font-size: 1.3rem;
margin-top: 1rem;
}
.author-footer {
padding: 5rem 0 3rem 0;
text-align: center;
}
.author-footer .author {
margin: 0 1rem 2rem 1rem;
padding: 0 0 1.6rem 0;
border-bottom: #EBF2F6 1px dashed;
}
.author-footer .connect {
position: static;
width: auto;
}
.author-footer .connect a {
margin: 1.4rem 0.8rem 0 0.8rem;
}
.author-meta li {
float: none;
margin: 0;
line-height: 1.75em;
}
.author-meta li:before {
display: none;
}
.older-posts,
.newer-posts {
position: static;
margin: 10px 0;
}
.page-number {
display: block;
}
.site-footer {
margin-top: 3rem;
}
.author-profile {
padding-bottom: 2rem;
}
.post-head.main-header {
height: 30%;
}
.tag-head.main-header,
.author-head.main-header {
height: 20%;
}
.author-profile .author-image {
margin-top: -70px;
}
.author-profile .author-meta span {
font-size: 1.4rem;
}
.archive-template .main-header .page-description {
display: none;
}
.author-footer {
margin-bottom: 0;
}
.author-footer .social {
float: none;
}
}
/* Used to fade in title/desc on the home page */
@-webkit-keyframes fade-in-down {
0% {
opacity: 0;
-webkit-transform: translateY(-10px);
transform: translateY(-10px);
}
100% {
opacity: 1;
-webkit-transform: translateY(0);
transform: translateY(0);
}
}
@keyframes fade-in-down {
0% {
opacity: 0;
-webkit-transform: translateY(-10px);
transform: translateY(-10px);
}
100% {
opacity: 1;
-webkit-transform: translateY(0);
transform: translateY(0);
}
}
/* Used to bounce .scroll-down on home page */
@-webkit-keyframes bounce {
0%, 10%, 25%, 40%, 50% {
-webkit-transform: translateY(0) rotate(-90deg);
transform: translateY(0) rotate(-90deg);
}
20% {
-webkit-transform: translateY(-10px) rotate(-90deg);
transform: translateY(-10px) rotate(-90deg);
}
30% {
-webkit-transform: translateY(-5px) rotate(-90deg);
transform: translateY(-5px) rotate(-90deg);
}
}
@keyframes bounce {
0%, 20%, 50%, 80%, 100% {
-webkit-transform: translateY(0) rotate(-90deg);
transform: translateY(0) rotate(-90deg);
}
40% {
-webkit-transform: translateY(-10px) rotate(-90deg);
transform: translateY(-10px) rotate(-90deg);
}
60% {
-webkit-transform: translateY(-5px) rotate(-90deg);
transform: translateY(-5px) rotate(-90deg);
}
}
|
<?php namespace ibrss\Http\Requests;
class RegisterRequest extends Request {
/**
* Get the validation rules that apply to the request.
*
* @return array
*/
public function rules()
{
return [
'email' => 'required|email|unique:users',
'password' => 'required|confirmed|min:8',
];
}
/**
* Determine if the user is authorized to make this request.
*
* @return bool
*/
public function authorize()
{
return true;
}
}
|
package util;
import java.io.<API key>;
import java.io.<API key>;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class ObjectCloner
{
// so that nobody can accidentally create an ObjectCloner object
private ObjectCloner() {
}
// returns a deep copy of an object
static public Object deepCopy(Object oldObj) throws Exception
{
ObjectOutputStream oos = null;
ObjectInputStream ois = null;
try
{
<API key> bos =
new <API key>();
oos = new ObjectOutputStream(bos);
// serialize and pass the object
oos.writeObject(oldObj);
oos.flush();
<API key> bin =
new <API key>(bos.toByteArray());
ois = new ObjectInputStream(bin);
// return the new object
return ois.readObject();
} catch (Exception e)
{
System.out.println("Exception in ObjectCloner = " + e);
throw (e);
} finally
{
oos.close();
ois.close();
}
}
}
|
import java.awt.*;
public class ListFonts
{
public static void main(String[] args)
{
String[] fontNames = GraphicsEnvironment
.<API key>()
.<API key>();
for (int i = 0; i < fontNames.length; i++)
System.out.println(fontNames[i]);
}
}
|
import { Event } from "../events/Event"
import { EventDispatcher } from "../events/EventDispatcher"
import { Browser } from "../utils/Browser"
import { Byte } from "../utils/Byte"
/**
*
* @eventType Event.OPEN
* */
/*[Event(name = "open", type = "laya.events.Event")]*/
/**
*
* @eventType Event.MESSAGE
* */
/*[Event(name = "message", type = "laya.events.Event")]*/
/**
*
* @eventType Event.CLOSE
* */
/*[Event(name = "close", type = "laya.events.Event")]*/
/**
*
* @eventType Event.ERROR
* */
/*[Event(name = "error", type = "laya.events.Event")]*/
/**
* <p> <code>Socket</code> HTML5 WebSocket full-duplex Browser/Client Agent </p>
* <p> <code>Socket</code> <code>new Socket</code> <code>Socket</code> <code>Socket</code> </p>
*/
export class Socket extends EventDispatcher {
/**
* <p> CPU </p>
* <p> LITTLE_ENDIAN </p>
* <p> BIG_ENDIAN </p>
*/
static LITTLE_ENDIAN: string = "littleEndian";
/**
* <p> CPU </p>
* <p> BIG_ENDIAN </p>
* <p> LITTLE_ENDIAN </p>
*/
static BIG_ENDIAN: string = "bigEndian";
/**@internal */
_endian: string;
/**@private */
protected _socket: any;
/**@private */
private _connected: boolean;
/**@private */
private _addInputPosition: number;
/**@private */
private _input: any;
/**@private */
private _output: any;
/**
* true
*/
disableInput: boolean = false;
/**
* <code>Byte</code>
*/
private _byteClass: new () => any;
protocols: any = [];
get input(): any {
return this._input;
}
get output(): any {
return this._output;
}
/**
* Socket
*/
get connected(): boolean {
return this._connected;
}
/**
* <p> CPU </p>
* <p> LITTLE_ENDIAN </p>
* <p> BIG_ENDIAN </p>
*/
get endian(): string {
return this._endian;
}
set endian(value: string) {
this._endian = value;
if (this._input != null) this._input.endian = value;
if (this._output != null) this._output.endian = value;
}
/**
* <p> Socket Socket.BIG_ENDIAN </p>
* @param host
* @param port
* @param byteClass Byte null Byte Byte
* @param protocols
* @see laya.utils.Byte
*/
constructor(host: string|null = null, port: number = 0, byteClass: new () => any = null, protocols: any[]|null = null) {
super();
this._byteClass = byteClass ? byteClass : Byte;
this.protocols = protocols;
this.endian = Socket.BIG_ENDIAN;
if (host && port > 0 && port < 65535) this.connect(host, port);
}
/**
* <p></p>
* <p> Event.OPEN Event.ERROR Event.CLOSE Event.MESSAGE Event.MESSAGE HTML DOM Event </p>
* @param host
* @param port
*/
connect(host: string, port: number): void {
var url: string = "ws://" + host + ":" + port;
this.connectByUrl(url);
}
/**
* <p> WebSocket URL URL ws://yourdomain:port</p>
* <p> Event.OPEN Event.ERROR Event.CLOSE Event.MESSAGE Event.MESSAGE HTML DOM Event </p>
* @param url WebSocket URL URL ws://yourdomain:port
*/
connectByUrl(url: string): void {
if (this._socket != null) this.close();
this._socket && this.cleanSocket();
if (!this.protocols || this.protocols.length == 0) {
this._socket = new Browser.window.WebSocket(url);
} else {
this._socket = new Browser.window.WebSocket(url, this.protocols);
}
this._socket.binaryType = "arraybuffer";
this._output = new this._byteClass();
this._output.endian = this.endian;
this._input = new this._byteClass();
this._input.endian = this.endian;
this._addInputPosition = 0;
this._socket.onopen = (e: any) => {
this._onOpen(e);
};
this._socket.onmessage = (msg: any): void => {
this._onMessage(msg);
};
this._socket.onclose = (e: any): void => {
this._onClose(e);
};
this._socket.onerror = (e: any): void => {
this._onError(e);
};
}
/**
* SocketSocketSocket
*/
cleanSocket(): void {
this.close();
this._connected = false;
this._socket.onopen = null;
this._socket.onmessage = null;
this._socket.onclose = null;
this._socket.onerror = null;
this._socket = null;
}
close(): void {
if (this._socket != null) {
try {
this._socket.close();
} catch (e) {
}
}
}
/**
* @private
*
*/
protected _onOpen(e: any): void {
this._connected = true;
this.event(Event.OPEN, e);
}
/**
* @private
*
* @param msg
*/
protected _onMessage(msg: any): void {
if (!msg || !msg.data) return;
var data: any = msg.data;
if (this.disableInput && data) {
this.event(Event.MESSAGE, data);
return;
}
if (this._input.length > 0 && this._input.bytesAvailable < 1) {
this._input.clear();
this._addInputPosition = 0;
}
var pre: number = this._input.pos;
!this._addInputPosition && (this._addInputPosition = 0);
this._input.pos = this._addInputPosition;
if (data) {
if (typeof (data) == 'string') {
this._input.writeUTFBytes(data);
} else {
this._input.writeArrayBuffer(data);
}
this._addInputPosition = this._input.pos;
this._input.pos = pre;
}
this.event(Event.MESSAGE, data);
}
/**
* @private
*
*/
protected _onClose(e: any): void {
this._connected = false;
this.event(Event.CLOSE, e)
}
/**
* @private
*
*/
protected _onError(e: any): void {
this.event(Event.ERROR, e)
}
/**
*
* @param data StringArrayBuffer
*/
send(data: any): void {
this._socket.send(data);
}
flush(): void {
if (this._output && this._output.length > 0) {
var evt: any;
try {
this._socket && this._socket.send(this._output.__getBuffer().slice(0, this._output.length));
} catch (e) {
evt = e;
}
this._output.endian = this.endian;
this._output.clear();
if (evt) this.event(Event.ERROR, evt);
}
}
}
|
'use strict';
module.exports = require('./is-implemented')() ?
Array.prototype.concat : require('./shim');
|
#!/bin/bash
# this causes the script to exit if any line causes an error. if there are badly-behaved bits of script that you want to ignore, you can run "set +e" and then "set -e" again afterwards.
set -e
# setting the variable stylefile to be the string on the RHS of =. you can't have spaces around the =, annoyingly.
# strings are either with double-quotes "" or single quotes ''. the difference is that the double quotes will substitute variables, e.g: if stylefile="x" then "foo_${stylefile}" is "foo_x", but 'foo_${stylefile}' is just 'foo_${stylefile}'
stylefile="targeted-editing/scripts/default.style"
# what i'm trying to do here is make it so that we can run the script as if we typed: import_db.sh database input query1 query2 ... queryN
# and the variables in the script get set as: dbname="database" inputfile="input" and $*="query1 query2 ... queryN"
# $1, $2, etc... are the first, second ... arguments to the script
dbname=$1 # array[1]
inputfile=$2 # array[2]
# shift offsets the arguments, so that after running "shift 2", what used to be $3 is now $1, what used to be $4 is now $2, and so forth
shift 2
# these are totally equivalent:
# dropdb --if-exists $dbname;
# dropdb --if-exists "$dbname";
# dropdb --if-exists ${dbname};
# dropdb --if-exists "${dbname}";
dropdb --if-exists $dbname;
# replace "user" below with your user name
createdb -E UTF-8 -O user $dbname;
psql -c "create extension postgis; create extension hstore; create extension btree_gist" $dbname;
# replace "user" below with your user name and adjust the amount of RAM you wish to allocate up or down from 12000(MB)
osm2pgsql -S $stylefile -d $dbname -C 12000 -s -G -x -k -K -U user -H /tmp $inputfile;
# for (var i = 0; i < array.length; i++) {
# var query = array[i];
for query in $*; do
echo "QUERY $query against database $dbname";
# `` is like a subselect, everything between the `` characters gets executed and replaced by whatever they output
# basename is a function which returns the file part of the filename, rather than the full path. so we can write "$(basename /very/long/path/with/lots/of/slashes.txt)" and it returns "slashes.txt"
query_base=`echo "$(basename $query)" | sed 's/\.sql
# execute the query and put its results ('>') in the file called "${dbname}_${query_base}.txt", so for a database called "new_york" and a query file called "fitness.sql", the output file would be "new_york_fitness.txt"
psql -f $query --quiet -t --no-align -F , $dbname | sed "s/^/${dbname},${query_base},/" > ${dbname}_${query_base}.txt;
done
|
import React from "react";
import { Link } from "@curi/react-dom";
import {
TitledPlainSection,
HashSection,
Paragraph,
CodeBlock,
Note,
IJS
} from "../../components/guide/common";
let meta = {
title: "Apollo Integration"
};
let setupMeta = {
title: "Setup",
hash: "setup"
};
let looseMeta = {
title: "Loose Pairing",
hash: "loose-pairing"
};
let prefetchMeta = {
title: "Prefetching",
hash: "prefetch"
};
let tightMeta = {
title: "Tight Pairing",
hash: "tight-pairing",
children: [prefetchMeta]
};
let contents = [setupMeta, looseMeta, tightMeta];
function ApolloGuide() {
return (
<React.Fragment>
<TitledPlainSection title={meta.title}>
<Paragraph>
<a href="https://apollographql.com">Apollo</a> is a great solution for
managing an application's data using{" "}
<a href="http://graphql.org">GraphQL</a>.
</Paragraph>
<Paragraph>
There are a few different implementation strategies for integrating
Apollo and Curi based on how tightly you want them to be paired.
</Paragraph>
<Note>
<Paragraph>
This guide only covers integration between Curi and Apollo. If you
are not already familiar with how to use Apollo, you will want to
learn that first.
</Paragraph>
<Paragraph>
Also, this guide will only be referencing Apollo's React
implementation, but the principles are the same no matter how you
render your application.
</Paragraph>
</Note>
</TitledPlainSection>
<HashSection meta={setupMeta} tag="h2">
<Paragraph>
Apollo's React package provides an <IJS>ApolloProvider</IJS> component
for accessing your Apollo client throughout the application. The{" "}
<IJS>Router</IJS> (or whatever you name the root Curi component)
should be a descendant of the <IJS>ApolloProvider</IJS> because we
don't need to re-render the <IJS>ApolloProvider</IJS> for every new
response.
</Paragraph>
<CodeBlock lang="jsx">
{`import { ApolloProvider } from "react-apollo";
import { <API key> } from "@curi/react-dom";
let Router = <API key>(router);
ReactDOM.render((
<ApolloProvider client={client}>
<Router>
<App />
</Router>
</ApolloProvider>
), holder);`}
</CodeBlock>
</HashSection>
<HashSection meta={looseMeta} tag="h2">
<Paragraph>
Apollo and Curi don't actually have to know about each other. Curi can
create a response without doing any data fetching and let Apollo
handle that with its <IJS>Query</IJS> component.
</Paragraph>
<CodeBlock>
{`// routes.js
import Noun from "./pages/Noun";
// nothing Apollo related in here
let routes = prepareRoutes([
{
name: 'Noun',
path: 'noun/:word',
respond: () => {
return {
body: Noun
};
}
}
]);`}
</CodeBlock>
<Paragraph>
Any location data that a query needs can be taken from the response
object. The best way to access this is to read the current{" "}
<IJS>response</IJS> from the context. This can either be done in the
component or the response can be passed down from the root app.
</Paragraph>
<CodeBlock lang="jsx">
{`import { useResponse } from "@curi/react-dom";
function App() {
let { response } = useResponse();
let { body:Body } = response;
return <Body response={response} />;
}`}
</CodeBlock>
<Paragraph>
Because we pass the <IJS>response</IJS> to the route's <IJS>body</IJS>{" "}
component, we can pass a <IJS>Query</IJS> the response's location
params using <IJS>props.response.params</IJS>.
</Paragraph>
<CodeBlock lang="jsx">
{`// pages/Nouns.js
import { Query } from "react-apollo";
let GET_NOUN = gql\`
query noun(\$word: String!) {
noun(word: $word) {
word,
type,
definition
}
}
\`;
// use the "word" param from the response props
// to query the correct data
let Noun = ({ response }) => (
<Query
query={GET_NOUN}
variables={{ word: response.params.word }}
>
{({ loading, error, data }) => {
if (loading) {
return <Loading />;
}
return (
<article>
<h1>{data.noun.word}</h1>
<Paragraph>{data.noun.definition}</Paragraph>
</article>
)
}}
</Query>
);`}
</CodeBlock>
</HashSection>
<HashSection meta={tightMeta} tag="h2">
<Paragraph>
You can use your Apollo client instance to call queries in a route's{" "}
<IJS>resolve</IJS> function. <IJS>resolve</IJS> is expected to return
a Promise, which is exactly what <IJS>client.query</IJS> returns.
Tightly pairing Curi and Apollo is mostly center around using{" "}
<IJS>resolve</IJS> to return a <IJS>client.query</IJS> call. This will
delay navigation until after a route's GraphQL data has been loaded by
Apollo.
</Paragraph>
<Paragraph>
The <IJS>external</IJS> option can be used when creating the router to
make the Apollo client accessible from routes.
</Paragraph>
<CodeBlock>
{`import client from "./apollo";
let router = createRouter(browser, routes, {
external: { client }
});`}
</CodeBlock>
<CodeBlock>
{`import { EXAMPLE_QUERY } from "./queries";
let routes = prepareRoutes([
{
name: "Example",
path: "example/:id",
resolve({ params }, external) {
return external.client.query({
query: EXAMPLE_QUERY,
variables: { id: params.id }
});
}
}
]);`}
</CodeBlock>
<Paragraph>There are two strategies for doing this.</Paragraph>
<Paragraph>
The first approach is to avoid the <IJS>Query</IJS> altogether.
Instead, you can use a route's <IJS>response</IJS> property to attach
the data fetched by Apollo directly to a response through its{" "}
<IJS>data</IJS> property.
</Paragraph>
<Paragraph>
While we know at this point that the query has executed, we should
also check <IJS>error</IJS> in the <IJS>respond</IJS> function to
ensure that the query was executed successfully.
</Paragraph>
<CodeBlock>
{`// routes.js
import GET_VERB from "./queries";
import Verb from "./pages/Verb";
export default [
{
name: "Verb",
path: "verb/:word",
resolve({ params }, external) {
return external.client.query({
query: GET_VERB,
variables: { word: params.word }
});
},
respond({ error, resolved }) {
if (error) {
// handle failed queries
}
return {
body: Verb,
data: resolved.verb.data
}
}
}
];`}
</CodeBlock>
<Paragraph>
When rendering, you can access the query data through the{" "}
<IJS>response</IJS>'s <IJS>data</IJS> property.
</Paragraph>
<CodeBlock lang="jsx">
{`// pages/Verb.js
let Verb = ({ response }) => (
<article>
<h1>{response.data.verb.word}</h1>
<Paragraph>
{response.data.verb.definition}
</Paragraph>
</article>
)`}
</CodeBlock>
<Paragraph>
The second approach is to use the <IJS>resolve</IJS> function as a way
to cache the data, but also use <IJS>Query</IJS>. With this approach,
we do not have to attach the query data to the response; we are
relying on the fact that Apollo will execute and cache the results
prior to navigation.
</Paragraph>
<CodeBlock>
{`// routes.js
import { GET_VERB } from "./queries";
export default [
{
name: "Verb",
path: "verb/:word",
resolve({ params, external }) {
// load the data so it is cached by
// your Apollo client
return external.client.query({
query: GET_VERB,
variables: { word: params.word }
});
}
}
];`}
</CodeBlock>
<Paragraph>
The route's component will render a <IJS>Query</IJS> to also call the
query. Because the query has already been executed, Apollo will grab
the data from its cache instead of re-sending a request to your
server.
</Paragraph>
<CodeBlock lang="jsx">
{`// pages/Verb.js
import { GET_VERB } from "../queries";
let Verb = ({ response }) => (
<Query
query={GET_VERB}
variables={{ word: response.params.word }}
>
{({ loading, error, data }) => {
return (
<article>
<h1>{data.verb.word}</h1>
<Paragraph>
{data.verb.definition}
</Paragraph>
</article>
);
}}
</Query>
)`}
</CodeBlock>
<HashSection meta={prefetchMeta} tag="h3">
<Paragraph>
One additional benefit of adding queries to routes using{" "}
<IJS>resolve</IJS> is that you can prefetch data for a route.
</Paragraph>
<Paragraph>
The{" "}
<Link
name="Package"
params={{ package: "interactions", version: "v2" }}
hash="prefetch"
>
<IJS>prefetch</IJS>
</Link>{" "}
interaction lets you programmatically fetch the data for a route
prior to navigating to a location.
</Paragraph>
<CodeBlock>
{`// index.js
import { prefetch } from "@curi/router";
let routes = prepareRoutes([
{
name: "Example",
path: "example/:id",
resolve({ params }, external) {
return external.client.query({
query: GET_EXAMPLES,
variables: { id: params.id }
});
}
}
]);
let router = createRouter(browser, routes);
// this will call the GET_EXAMPLES query
// and Apollo will cache the results
let exampleRoute = router.route("Example");
prefetch(exampleRoute, { params: { id: 2 }});`}
</CodeBlock>
</HashSection>
</HashSection>
</React.Fragment>
);
}
export { ApolloGuide as component, contents };
|
require 'net/http'
require 'net/https'
require 'active_merchant/billing/response'
module ActiveMerchant #:nodoc:
module Billing #:nodoc:
# == Description
# The Gateway class is the base class for all ActiveMerchant gateway implementations.
# The standard list of gateway functions that most concrete gateway subclasses implement is:
# * <tt>purchase(money, creditcard, options = {})</tt>
# * <tt>authorize(money, creditcard, options = {})</tt>
# * <tt>capture(money, authorization, options = {})</tt>
# * <tt>void(identification, options = {})</tt>
# * <tt>credit(money, identification, options = {})</tt>
# Some gateways include features for recurring billing
# * <tt>recurring(money, creditcard, options = {})</tt>
# Some gateways also support features for storing credit cards:
# * <tt>store(creditcard, options = {})</tt>
# * <tt>unstore(identification, options = {})</tt>
# The options hash consists of the following options:
# * <tt>:order_id</tt> - The order number
# * <tt>:ip</tt> - The IP address of the customer making the purchase
# * <tt>:customer</tt> - The name, customer number, or other information that identifies the customer
# * <tt>:invoice</tt> - The invoice number
# * <tt>:merchant</tt> - The name or description of the merchant offering the product
# * <tt>:description</tt> - A description of the transaction
# * <tt>:email</tt> - The email address of the customer
# * <tt>:currency</tt> - The currency of the transaction. Only important when you are using a currency that is not the default with a gateway that supports multiple currencies.
# * <tt>:billing_address</tt> - A hash containing the billing address of the customer.
# * <tt>:shipping_address</tt> - A hash containing the shipping address of the customer.
# The <tt>:billing_address</tt>, and <tt>:shipping_address</tt> hashes can have the following keys:
# * <tt>:name</tt> - The full name of the customer.
# * <tt>:company</tt> - The company name of the customer.
# * <tt>:address1</tt> - The primary street address of the customer.
# * <tt>:address2</tt> - Additional line of address information.
# * <tt>:city</tt> - The city of the customer.
# * <tt>:state</tt> - The state of the customer. The 2 digit code for US and Canadian addresses. The full name of the state or province for foreign addresses.
# * <tt>:zip</tt> - The zip or postal code of the customer.
# * <tt>:phone</tt> - The phone number of the customer.
# == Implmenting new gateways
class Gateway
include PostsData
include RequiresParameters
include <API key>
include Utils
DEBIT_CARDS = [ :switch, :solo ]
cattr_reader :implementations
@@implementations = []
def self.inherited(subclass)
super
@@implementations << subclass
end
# The format of the amounts used by the gateway
# :dollars => '12.50'
# :cents => '1250'
<API key> :money_format
self.money_format = :dollars
# The default currency for the transactions if no currency is provided
<API key> :default_currency
# The countries of merchants the gateway supports
<API key> :supported_countries
self.supported_countries = []
# The supported card types for the gateway
<API key> :supported_cardtypes
self.supported_cardtypes = []
# Indicates if the gateway supports 3D Secure authentication or not
<API key> :supports_3d_secure
self.supports_3d_secure = false
<API key> :homepage_url
<API key> :display_name
# The application making the calls to the gateway
# Useful for things like the PayPal build notation (BN) id fields
<API key> :application_id
self.application_id = 'ActiveMerchant'
attr_reader :options
# Use this method to check if your gateway of interest supports a credit card of some type
def self.supports?(card_type)
supported_cardtypes.include?(card_type.to_sym)
end
def self.card_brand(source)
result = source.respond_to?(:brand) ? source.brand : source.type
result.to_s.downcase
end
def card_brand(source)
self.class.card_brand(source)
end
# Initialize a new gateway.
# See the documentation for the gateway you will be using to make sure there are no other
# required options.
def initialize(options = {})
end
# Are we running in test mode?
def test?
Base.gateway_mode == :test
end
private # :nodoc: all
def name
self.class.name.scan(/\:\:(\w+)Gateway/).flatten.first
end
def amount(money)
return nil if money.nil?
cents = if money.respond_to?(:cents)
warn "Support for Money objects is deprecated and will be removed from a future release of ActiveMerchant. Please use an Integer value in cents"
money.cents
else
money
end
if money.is_a?(String) or cents.to_i < 0
raise ArgumentError, 'money amount must be a positive Integer in cents.'
end
if self.money_format == :cents
cents.to_s
else
sprintf("%.2f", cents.to_f / 100)
end
end
def currency(money)
money.respond_to?(:currency) ? money.currency : self.default_currency
end
def <API key>?(credit_card)
return false if card_brand(credit_card).blank?
DEBIT_CARDS.include?(card_brand(credit_card).to_sym)
end
end
end
end
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
namespace DevDataControl
{
public partial class <API key> : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
}
}
}
|
require 'tilt/erb'
module May
class Templator
class Template
def initialize(path)
@file = File.open(path, 'r') if path
end
def path
@file.path
end
def body
return '' unless @file
@body ||= @file.read
end
end
class Generator
def initialize(bind)
@binding = bind
end
def generate(template)
Tilt::ERBTemplate.new(template.path, { trim: '<>' }).render(@binding)
end
end
def initialize(template_path, destination, bind)
@template_path, @destination, @binding = template_path, destination, bind
end
def render
template = Template.new(@template_path)
Generator.new(@binding).generate(template)
end
def write
File.open(@destination, 'w') do |f|
f.puts render
end
end
end
end
|
/**
* before : before(el, newEl)
* Inserts a new element `newEl` just before `el`.
*
* var before = require('dom101/before');
* var newNode = document.createElement('div');
* var button = document.querySelector('#submit');
*
* before(button, newNode);
*/
function before (el, newEl) {
if (typeof newEl === 'string') {
return el.insertAdjacentHTML('beforebegin', newEl)
} else {
return el.parentNode.insertBefore(newEl, el)
}
}
module.exports = before
|
<? $page_title = "Mobile Grid System" ?>
<?php include("includes/_header.php"); ?>
<style>
.example .row, .example .row .column, .example .row .columns { background: #f4f4f4; }
.example .row { margin-bottom: 10px; }
.example .row .column, .example .row .columns { background: #eee; border: 1px solid #ddd; }
@media handheld, only screen and (max-width: 767px) {
.example .row { height: auto; }
.example .row .column, .example .row .columns { margin-bottom: 10px; }
.example .row .column:last-child, .example .row .columns:last-child { margin-bottom: 0; }
}
</style>
<header>
<div class="row">
<div class="twelve columns">
<h1>Mobile Grids</h1>
<h4></h4>
</div>
</div>
</header>
<section id="mainContent" class="example">
<div class="row">
<div class="twelve columns">
<h3>On phones, columns become stacked.</h3>
<p>That means this twelve column section will be the full width, and so will the three sections you see below.</p>
</div>
</div>
<div class="row">
<div class="four columns">
<h5>Section 1</h5>
<img src="http://placehold.it/300x100" />
<p>This is a four column section (so three of them across add up to twelve). As noted above on mobile, these columns will be stacked on top of each other.</p>
</div>
<div class="four columns">
<h5>Section 2</h5>
<img src="http://placehold.it/300x100" />
<p>This is another four column section which will be stacked on top of the others. The next section though…</p>
</div>
<div class="four columns">
<h5>Section 3</h5>
<p>Here we've used a block grid (.block-grid.three-up). These are perfect for similarly sized elements that you want to present in a grid even on mobile devices. If you view this on a phone (or small browser window) you can see what we mean.</p>
<ul class="block-grid three-up">
<li>
<img src="http://placehold.it/128x128" />
</li>
<li>
<img src="http://placehold.it/128x128" />
</li>
<li>
<img src="http://placehold.it/128x128" />
</li>
<li>
<img src="http://placehold.it/128x128" />
</li>
<li>
<img src="http://placehold.it/128x128" />
</li>
<li>
<img src="http://placehold.it/128x128" />
</li>
</ul>
</div>
</div>
</section>
<?php include("includes/_footer.php"); ?>
|
package astilog
import "flag"
// Flags
var (
AppName = flag.String("logger-app-name", "", "the logger's app name")
Filename = flag.String("logger-filename", "", "the logger's filename")
Verbose = flag.Bool("logger-verbose", false, "if true, then log level is debug")
)
// Formats
const (
FormatJSON = "json"
FormatText = "text"
)
// Outs
const (
OutFile = "file"
OutStdOut = "stdout"
OutSyslog = "syslog"
)
// Configuration represents the configuration of the logger
type Configuration struct {
AppName string `toml:"app_name"`
DisableColors bool `toml:"disable_colors"`
DisableTimestamp bool `toml:"disable_timestamp"`
Filename string `toml:"filename"`
FullTimestamp bool `toml:"full_timestamp"`
Format string `toml:"format"`
MessageKey string `toml:"message_key"`
Out string `toml:"out"`
TimestampFormat string `toml:"timestamp_format"`
Verbose bool `toml:"verbose"`
}
// SetHandyFlags sets handy flags
func SetHandyFlags() {
Verbose = flag.Bool("v", false, "if true, then log level is debug")
}
// FlagConfig generates a Configuration based on flags
func FlagConfig() Configuration {
return Configuration{
AppName: *AppName,
Filename: *Filename,
Verbose: *Verbose,
}
}
|
<?php
require_once('../../lib/Laposta.php');
Laposta::setApiKey("<API key>");
// initialize field with list_id
$field = new Laposta_Field("BaImMu3JZA");
try {
// get field info, use field_id or email as argument
// $result will contain een array with the response from the server
$result = $field->get("iPcyYaTCkG");
print '<pre>';print_r($result);print '</pre>';
} catch (Exception $e) {
// you can use the information in $e to react to the exception
print '<pre>';print_r($e);print '</pre>';
}
?>
|
import React, { PropTypes } from 'react';
import Page from './Page';
import ProjectListItem from './ProjectListItem';
import AspectContainer from './AspectContainer';
import BannerImage from './BannerImage';
import styles from './Projects.css';
const Projects = ({ projects }) => (
<Page
Hero={() =>
<AspectContainer>
<BannerImage url="https://placebear.com/900/1200" />
</AspectContainer>
}
title="Projects"
>
<div className={styles.projects}>
{projects.map(project => <ProjectListItem key={project.id} {...project} />)}
</div>
</Page>
);
Projects.propTypes = {
projects: PropTypes.arrayOf(PropTypes.object),
};
export default Projects;
|
(function($) {
var <API key> = function() {
this.token = localStorage.getItem('token');
this.gitlab_host = localStorage.getItem('gitlab_host');
}
<API key>.prototype.save = function() {
localStorage.setItem('token', this.token);
localStorage.setItem('gitlab_host', this.gitlab_host);
$(this).trigger('updated');
}
var <API key> = function(form, config) {
this.form = form;
this.statusField = $('#form-status', form)
this.config = config;
this.form.submit(this.onSubmit.bind(this));
};
<API key>.prototype.updateStatus = function(string) {
this.statusField.text(string).show();
};
<API key>.prototype.onSubmit = function(e) {
var values = this.form.serializeArray();
for( var i in values ) {
this.config[values[i].name] = values[i].value;
}
this.config.save();
this.updateStatus('Data saved!');
return false;
}
var <API key> = function(element) {
this.configurationList = element;
};
<API key>.prototype.display = function(config) {
var tokenValue = $('<li>').text('Token: ' + config.token);
var hostnameValue = $('<li>').text('Hostname: ' + config.gitlab_host);
this.configurationList.empty();
this.configurationList.append(tokenValue);
this.configurationList.append(hostnameValue);
};
$(document).ready(function() {
var form = $('#fourth-wall-config');
var savedValues = $('#saved-values');
var config = new <API key>();
var form = new <API key>(form, config);
var configDisplay = new <API key>(savedValues);
configDisplay.display(config);
$(config).on('updated', function() {
configDisplay.display(config);
});
});
})(jQuery);
|
<ts-form-field
[validateOnChange]="validateOnChange"
[control]="selfReference"
[hideRequiredMarker]="hideRequiredMarker"
[hint]="hint"
[id]="id"
[theme]="theme"
cdk-overlay-origin
#origin="cdkOverlayOrigin"
>
<ts-label *ngIf="label">
{{ label }}
</ts-label>
<div class="<API key>">
<ng-container *ngIf="allowMultiple">
<ts-chip-collection
[<API key>]="true"
[isDisabled]="false"
[isReadonly]="false"
(tabUpdateFocus)="focusInput()"
#chipCollection="tsChipCollection"
>
<ts-chip
*ngFor="let chip of <API key>.value; trackBy: trackByFn"
[isRemovable]="true"
[isDisabled]="isDisabled"
[value]="chip"
(remove)="<API key>($event.chip)"
>{{ displayFormatter(chip) }}</ts-chip>
<input
class="<API key> <API key>"
[<API key>]="auto"
[<API key>]="<API key>"
[attr.id]="id"
[(ngModel)]="searchQuery"
[readonly]="isDisabled ? 'true' : null"
(ngModelChange)="querySubject.next($event)"
(blur)="handleInputBlur($event)"
#input
/>
</ts-chip-collection>
<ng-template *ngTemplateOutlet="spinnerTemplate"></ng-template>
</ng-container>
<ng-container *ngIf="!allowMultiple">
<input
class="<API key> <API key>"
[<API key>]="auto"
[attr.id]="id"
[readonly]="isDisabled ? 'true' : null"
[(ngModel)]="searchQuery"
[value]="searchQuery"
(ngModelChange)="querySubject.next($event)"
(blur)="handleInputBlur($event)"
#input
/>
<ng-template *ngTemplateOutlet="spinnerTemplate"></ng-template>
</ng-container>
</div>
</ts-form-field>
<<API key>
class="ts-autocomplete"
#auto="tsAutocompletePanel"
[id]="id + '-panel'"
[options]="options"
[optionGroups]="optionGroups"
(optionSelected)="<API key>($event)"
>
<!-- Outlet for options passed in by consumer -->
<ng-template *ngTemplateOutlet="contentTemplate"></ng-template>
</<API key>>
<ng-template #contentTemplate>
<ng-content></ng-content>
</ng-template>
<ng-template #spinnerTemplate>
<<API key>
*ngIf="showProgress"
class="<API key> <API key>--{{theme}} <API key>"
[ngClass]="{'<API key>': showProgress}"
diameter="21"
mode="indeterminate"
></<API key>>
</ng-template>
|
"use strict";
ace.define("ace/snippets/golang", ["require", "exports", "module"], function (require, exports, module) {
"use strict";
exports.snippetText = undefined;
exports.scope = "golang";
});
|
<API key> $MyInvocation
try {
. $PSScriptRoot\Get-PythonExe.ps1
$distdir = Get-VstsInput -Name "distdir" -Require
$repository = Get-VstsInput -Name "repository" -Require
$pypirc = Get-VstsInput -Name "pypirc"
$username = Get-VstsInput -Name "username"
$password = Get-VstsInput -Name "password"
$python = Get-PythonExe -Name "pythonpath"
$dependencies = Get-VstsInput -Name "dependencies"
$skipexisting = Get-VstsInput -Name "skipexisting" -AsBool -Require
$otherargs = Get-VstsInput -Name "otherargs"
if ($dependencies) {
Invoke-VstsTool $python "-m pip install $dependencies"
}
if ($repository -match '^HTTP') {
$args = "--repository-url $repository"
} else {
$args = "-r $repository"
}
if ($pypirc -and (Test-Path $pypirc -PathType Leaf)) {
$args = '{0} --config-file "{1}"' -f ($args, $pypirc)
}
if ($skipexisting) {
$args = "$args --skip-existing"
}
if ($otherargs) {
$args = "$args $otherargs"
}
try {
$env:TWINE_USERNAME = $username
$env:TWINE_PASSWORD = $password
if (Test-Path $distdir -PathType Container) {
$distdir = Join-Path $distdir '*'
}
$arguments = '-m twine upload "{0}" {1}' -f ($distdir, $args)
Invoke-VstsTool $python $arguments -RequireExitCodeZero
} finally {
$env:TWINE_USERNAME = $null
$env:TWINE_PASSWORD = $null
}
} finally {
<API key> $MyInvocation
}
|
<html><body>
<h4>Windows 10 x64 (19041.208) 2004</h4><br>
<h2><API key></h2>
<font face="arial"> +0x000 Base : <a href="./_VF_AVL_TREE_NODE.html">_VF_AVL_TREE_NODE</a><br>
+0x010 SessionId : Uint4B<br>
</font></body></html>
|
#ifndef SIGNALS_H_
#define SIGNALS_H_
//Lightbarriers and Sensor
#define INLET_IN_VAL 0b0000000000000001
#define INLET_OUT_VAL 0b0000000000000011
#define <API key> 0b0000000000000010
#define <API key> 0b0000000000000110
//#define SENSOR_HEIGHT 0b0000000000000100
#define SWITCH_IN_VAL 0b0000000000001000
#define SWITCH_OUT_VAL 0b0000000000011000
#define METAL_DETECT_VAL 0b0000000000010000
#define SWITCH_OPEN_VAL 0b0000000000100000
#define SWITCH_CLOSED_VAL 0b0000000001100000
#define SLIDE_IN_VAL 0b0000000001000000
#define SLIDE_OUT_VAL 0b0000000011000000
#define OUTLET_IN_VAL 0b0000000010000000
#define OUTLET_OUT_VAL 0b0000000110000000
//Buttons
#define BUTTON_START_VAL 0b0001000000000000
#define BUTTON_STOP_VAL 0b0010000000000000
#define BUTTON_RESET_VAL 0b0100000000000000
#define BUTTON_ESTOP_IN_VAL 0b1000000000000000
#define <API key> 0b1100000000000000
namespace interrupts {
enum interruptSignals : int32_t {
INLET_IN = INLET_IN_VAL,
INLET_OUT = INLET_OUT_VAL,
<API key> = <API key>,
<API key> = <API key>,
SWITCH_IN = SWITCH_IN_VAL,
SWITCH_OUT = SWITCH_OUT_VAL,
METAL_DETECT = METAL_DETECT_VAL,
SWITCH_OPEN = SWITCH_OPEN_VAL,
SWITCH_CLOSED = SWITCH_CLOSED_VAL,
SLIDE_IN = SLIDE_IN_VAL,
SLIDE_OUT = SLIDE_OUT_VAL,
OUTLET_IN = OUTLET_IN_VAL,
OUTLET_OUT = OUTLET_OUT_VAL,
BUTTON_START = BUTTON_START_VAL,
BUTTON_STOP = BUTTON_STOP_VAL,
BUTTON_RESET = BUTTON_RESET_VAL,
BUTTON_ESTOP_IN = BUTTON_ESTOP_IN_VAL,
BUTTON_ESTOP_OUT = <API key>
};
}
#endif /* SIGNALS_H_ */
|
html {
font-size: 12px;
font-family: 'Rubik', sans-serif;
}
h1,h2,h3,h4,h5,h6 {
font-family: 'Rubik Mono One',sans-serif;
}
header {
text-align: center;
}
header h1 {
margin: 0;
}
#countries-judged {
margin-bottom: 2rem;
min-height: 2rem;
}
#countries-judged.empty {
border: 1px dashed;
}
#countries-unjudged .country {
background: hsl(341, 38%, 53%);
}
#spacer {
width: 100%;
height: 2rem;
}
.country {
display: grid;
background: #b82352;
color: white;
<API key>: 3rem 2rem 1fr 4rem 2fr;
grid-template-areas: "score flag name picture artist" "score flag name picture title";
grid-gap: 0rem 0.5rem;
padding: 0.2rem;
}
#judging .country {
cursor: ns-resize;
}
.country a {
color: white;
text-decoration: none;
}
.country a:hover {
text-decoration: underline;
}
.country .play {
color: lightgreen;
}
.country > * {align-self: center;}
.country ~ .country {
margin-top: 0.5rem;
}
.country .picture img {
height: 4rem;
width: 4rem;
object-fit: cover;
object-position: center;
display: block;
}
.country .points {
font-size: 2rem;
text-align: right;
}
.country .flag-icon {
height: 2rem;
line-height: 2rem;
width: 2rem;
}
body {
margin: 0;
min-height: 101vh;
}
div#app {
width: 100%;
}
.country .points {
grid-area: score;
justify-self: end;
align-self: center;
}
.country .flag {
grid-area: flag;
align-self: center;
}
.country .name {
grid-area: name;
align-self: center;
}
.country .picture {
grid-area: picture;
}
.country .artist {
grid-area: artist;
}
.country .title {
grid-area: title;
}
input#name {
font-size: 1rem;
padding: 1em;
}
#leaderboard ol {
padding: 0;
list-style: none;
}
nav {
display:flex;
}
nav button {
flex: 1;
}
button {
background: #2b282b;
border: none;
font-size: 2rem;
padding: 0.5em;
color: white;
border-top: 5px solid #2b282b;
}
button.active {
background: hsl(300, 4%, 100%);
color: #2b282b;
}
section {
background: #fafafa;
padding-top: 1rem;
padding-left: 1rem;
}
section#judging div {
padding-left: 1rem;
}
footer {
text-align: right;
padding: 0 1rem;
margin-top: 5rem;
}
@media screen and (min-width:795px) {
.country {
<API key>: 3rem 2rem 1fr 8rem 2fr 2fr;
grid-template-areas: "score flag name picture artist title";
}
.country .picture img {
width: 8rem;
height: 3rem;
}
}
@media screen and (min-width: 960px) {
html {
font-size: 15px;
}
}
@media screen and (min-width: 1240px) {
html {
font-size: 15px;
}
}
@media screen and (min-width: 1490px) {
html {
font-size: 24px;
}
}
|
<?php
namespace Composer\Plugin;
use Composer\Composer;
use Composer\EventDispatcher\<API key>;
use Composer\IO\IOInterface;
use Composer\Package\Package;
use Composer\Package\Version\VersionParser;
use Composer\Repository\RepositoryInterface;
use Composer\Package\AliasPackage;
use Composer\Package\PackageInterface;
use Composer\Package\Link;
use Composer\Package\LinkConstraint\VersionConstraint;
use Composer\DependencyResolver\Pool;
/**
* Plugin manager
*
* @author Nils Adermann <naderman@naderman.de>
* @author Jordi Boggiano <j.boggiano@seld.be>
*/
class PluginManager
{
protected $composer;
protected $io;
protected $globalComposer;
protected $versionParser;
protected $plugins = array();
protected $registeredPlugins = array();
private static $classCounter = 0;
/**
* Initializes plugin manager
*
* @param IOInterface $io
* @param Composer $composer
* @param Composer $globalComposer
*/
public function __construct(IOInterface $io, Composer $composer, Composer $globalComposer = null)
{
$this->io = $io;
$this->composer = $composer;
$this->globalComposer = $globalComposer;
$this->versionParser = new VersionParser();
}
/**
* Loads all plugins from currently installed plugin packages
*/
public function <API key>()
{
$repo = $this->composer-><API key>()->getLocalRepository();
$globalRepo = $this->globalComposer ? $this->globalComposer-><API key>()->getLocalRepository() : null;
if ($repo) {
$this->loadRepository($repo);
}
if ($globalRepo) {
$this->loadRepository($globalRepo);
}
}
/**
* Adds a plugin, activates it and registers it with the event dispatcher
*
* @param PluginInterface $plugin plugin instance
*/
public function addPlugin(PluginInterface $plugin)
{
$this->plugins[] = $plugin;
$plugin->activate($this->composer, $this->io);
if ($plugin instanceof <API key>) {
$this->composer->getEventDispatcher()->addSubscriber($plugin);
}
}
/**
* Gets all currently active plugin instances
*
* @return array plugins
*/
public function getPlugins()
{
return $this->plugins;
}
/**
* Load all plugins and installers from a repository
*
* Note that plugins in the specified repository that rely on events that
* have fired prior to loading will be missed. This means you likely want to
* call this method as early as possible.
*
* @param RepositoryInterface $repo Repository to scan for plugins to install
*
* @throws \RuntimeException
*/
public function loadRepository(RepositoryInterface $repo)
{
foreach ($repo->getPackages() as $package) {
if ($package instanceof AliasPackage) {
continue;
}
if ('composer-plugin' === $package->getType()) {
$requiresComposer = null;
foreach ($package->getRequires() as $link) {
if ($link->getTarget() == 'composer-plugin-api') {
$requiresComposer = $link->getConstraint();
}
}
if (!$requiresComposer) {
throw new \RuntimeException("Plugin ".$package->getName()." is missing a require statement for a version of the composer-plugin-api package.");
}
if (!$requiresComposer->matches(new VersionConstraint('==', $this->versionParser->normalize(PluginInterface::PLUGIN_API_VERSION)))) {
$this->io->write("<warning>The plugin ".$package->getName()." requires a version of composer-plugin-api that does not match your composer installation. You may need to run composer update with the '--no-plugins' option.</warning>");
}
$this->registerPackage($package);
}
// Backward compatibility
if ('composer-installer' === $package->getType()) {
$this->registerPackage($package);
}
}
}
/**
* Recursively generates a map of package names to packages for all deps
*
* @param Pool $pool Package pool of installed packages
* @param array $collected Current state of the map for recursion
* @param PackageInterface $package The package to analyze
*
* @return array Map of package names to packages
*/
protected function collectDependencies(Pool $pool, array $collected, PackageInterface $package)
{
$requires = array_merge(
$package->getRequires(),
$package->getDevRequires()
);
foreach ($requires as $requireLink) {
$requiredPackage = $this-><API key>($pool, $requireLink);
if ($requiredPackage && !isset($collected[$requiredPackage->getName()])) {
$collected[$requiredPackage->getName()] = $requiredPackage;
$collected = $this->collectDependencies($pool, $collected, $requiredPackage);
}
}
return $collected;
}
/**
* Resolves a package link to a package in the installed pool
*
* Since dependencies are already installed this should always find one.
*
* @param Pool $pool Pool of installed packages only
* @param Link $link Package link to look up
*
* @return PackageInterface|null The found package
*/
protected function <API key>(Pool $pool, Link $link)
{
$packages = $pool->whatProvides($link->getTarget(), $link->getConstraint());
return (!empty($packages)) ? $packages[0] : null;
}
/**
* Register a plugin package, activate it etc.
*
* If it's of type composer-installer it is registered as an installer
* instead for BC
*
* @param PackageInterface $package
* @param bool $<API key> By default this silently skips plugins that can not be found, but if set to true it fails with an exception
*
* @throws \<API key>
*/
public function registerPackage(PackageInterface $package, $<API key> = false)
{
$oldInstallerPlugin = ($package->getType() === 'composer-installer');
if (in_array($package->getName(), $this->registeredPlugins)) {
return;
}
$extra = $package->getExtra();
if (empty($extra['class'])) {
throw new \<API key>('Error while installing '.$package->getPrettyName().', composer-plugin packages should have a class defined in their extra key to be usable.');
}
$classes = is_array($extra['class']) ? $extra['class'] : array($extra['class']);
$localRepo = $this->composer-><API key>()->getLocalRepository();
$globalRepo = $this->globalComposer ? $this->globalComposer-><API key>()->getLocalRepository() : null;
$pool = new Pool('dev');
$pool->addRepository($localRepo);
if ($globalRepo) {
$pool->addRepository($globalRepo);
}
$autoloadPackages = array($package->getName() => $package);
$autoloadPackages = $this->collectDependencies($pool, $autoloadPackages, $package);
$generator = $this->composer-><API key>();
$autoloads = array();
foreach ($autoloadPackages as $autoloadPackage) {
$downloadPath = $this->getInstallPath($autoloadPackage, ($globalRepo && $globalRepo->hasPackage($autoloadPackage)));
$autoloads[] = array($autoloadPackage, $downloadPath);
}
$map = $generator->parseAutoloads($autoloads, new Package('dummy', '1.0.0.0', '1.0.0'));
$classLoader = $generator->createLoader($map);
$classLoader->register();
foreach ($classes as $class) {
if (class_exists($class, false)) {
$code = file_get_contents($classLoader->findFile($class));
$code = preg_replace('{^(\s*)class\s+(\S+)}mi', '$1class $2_composer_tmp'.self::$classCounter, $code);
eval('?>'.$code);
$class .= '_composer_tmp'.self::$classCounter;
self::$classCounter++;
}
if ($oldInstallerPlugin) {
$installer = new $class($this->io, $this->composer);
$this->composer-><API key>()->addInstaller($installer);
} elseif (class_exists($class)) {
$plugin = new $class();
$this->addPlugin($plugin);
$this->registeredPlugins[] = $package->getName();
} elseif ($<API key>) {
throw new \<API key>('Plugin '.$package->getName().' could not be initialized, class not found: '.$class);
}
}
}
/**
* Retrieves the path a package is installed to.
*
* @param PackageInterface $package
* @param bool $global Whether this is a global package
*
* @return string Install path
*/
public function getInstallPath(PackageInterface $package, $global = false)
{
if (!$global) {
return $this->composer-><API key>()->getInstallPath($package);
}
return $this->globalComposer-><API key>()->getInstallPath($package);
}
}
|
export default {
modules: require('glob!./glob.txt'),
options: {
name: 'Comment',
},
info: true,
utils: {},
};
|
using Content.Shared.Sound;
using Robust.Shared.GameObjects;
using Robust.Shared.Serialization.Manager.Attributes;
using Robust.Shared.ViewVariables;
namespace Content.Server.Storage.Components
{
<summary>
Allows locking/unlocking, with access determined by AccessReader
</summary>
[RegisterComponent]
public sealed class LockComponent : Component
{
[ViewVariables(VVAccess.ReadWrite)] [DataField("locked")] public bool Locked { get; set; } = true;
[ViewVariables(VVAccess.ReadWrite)] [DataField("lockOnClick")] public bool LockOnClick { get; set; } = false;
[ViewVariables(VVAccess.ReadWrite)] [DataField("unlockingSound")] public SoundSpecifier UnlockSound { get; set; } = new SoundPathSpecifier("/Audio/Machines/door_lock_off.ogg");
[ViewVariables(VVAccess.ReadWrite)] [DataField("lockingSound")] public SoundSpecifier LockSound { get; set; } = new SoundPathSpecifier("/Audio/Machines/door_lock_off.ogg");
}
}
|
using System;
using System.Collections.Generic;
using System.Text;
namespace RaidScheduler.Domain.DomainModels.Combinations
{
<summary>
Interface for Permutations, Combinations and any other classes that present
a collection of collections based on an input collection. The enumerators that
this class inherits defines the mechanism for enumerating through the collections.
</summary>
<typeparam name="T">The of the elements in the collection, not the type of the collection.</typeparam>
interface IMetaCollection<T> : IEnumerable<IList<T>> {
<summary>
The count of items in the collection. This is not inherited from
ICollection since this meta-collection cannot be extended by users.
</summary>
long Count { get; }
<summary>
The type of the meta-collection, determining how the collections are
determined from the inputs.
</summary>
GenerateOption Type { get; }
<summary>
The upper index of the meta-collection, which is the size of the input collection.
</summary>
int UpperIndex { get; }
<summary>
The lower index of the meta-collection, which is the size of each output collection.
</summary>
int LowerIndex { get; }
}
}
|
using DragonSpark.Model.Results;
namespace DragonSpark.Application.Security.Identity;
public interface IUsers<T> : IResult<UsersSession<T>> where T : class {}
|
#!/usr/bin/env node
process.env.FORCE_COLOR = true;
const program = require('commander');
const package = require('../package.json');
/**
* CLI Commands
*
*/
program
.version((package.name) + '@' + (package.version));
/**
* Command for creating and seeding
*/
program
.command('create [dataObject]', 'Generate seed data').alias('c')
.command('teardown', 'Tear down seed data').alias('t')
.parse(process.argv);
|
+++
date = "2019-03-01T18:09:26-07:00"
title = "Trust and Integrity"
author = "Jessica Frazelle"
description = "Some reflections on my recent adventures."
+++
I stated in my first post on my [reflections of leadership in other
industries](https://blog.jessfraz.com/post/<API key>/)
that I would write a follow up post after having hung out in the world of
finance for a day. This is pretty easy to do when you live in NYC.
Originally for college, I was a finance major at NYU Stern School of Business
before transferring out, so I have always had a bit of affinity for it.
I consider myself pretty good at reading people. This, of course, was not
always the case. I became better at reading people after having a few really
bad experiences where I should have known better than to trust someone. I've
read a bunch of books on how to tell when people are lying and my favorite
I called out in my [books post](https://blog.jessfraz.com/post/books/). This is
not something I wish that I had to learn but it does protect you from people
who might not have the best intentions.
Most people will tell you to always assume good intentions, and this is true to
an extent. However, having been through some really bad experiences where I did
"assume good intentions" and should not have, I tend to be less and less willing
to do that.
I am saying this, not because I think people in finance are shady, they
aren't, but because I believe it is important in any field. I, personally, place a lot of value on trust and
integrity.
I'm not really going to focus this post on what an investment bankers job is
like because honestly it wasn't really anything to write home about. What I did
find interesting was the lack of trust in the workplace. Trust is a huge thing
for me, like I said, and I think having transparency goes hand-in-hand with that.
To gain trust, I believe a leader must also have integrity and a track record
of doing the right thing. I liked this response to a tweet of mine about using "trust
tokens" in the case leadership needs to keep something private.
<blockquote class="twitter-tweet" data-lang="en"><p lang="en" dir="ltr">They are. It gets hard with legal things like SEC filings and acquisitions but that’s where an already good leadership team can use existing trust tokens.</p>— Silvia Botros (@dbsmasher) <a href="https://twitter.com/dbsmasher/status/1098602904838197253?ref_src=twsrc%5Etfw">February 21, 2019</a></blockquote>
<script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>
I think people tend to under estimate how important it is to be transparent
about things that don't need to be private. I've seen a lot of people in
positions of power, use their power of keeping information private _against_
those under them. They don't fully disclose the "why" and it leads to people
they manage not fully being able to help solve the problem as well as not fully
understanding the problem. It also doesn't build trust.
Leaders should try to be cognisant of when something needs to be private and
when they can be transparent about information. I also really enjoyed this
insightful tweet as well:
<blockquote class="twitter-tweet" data-lang="en"><p lang="en" dir="ltr">Unlike respect, which can start from a positive value and go up or down depending on behavior, trust starts at 0. You have to earn the trust of your colleagues and reports before you can take loans out on it. <a href="https:
<script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>
Just thought I would put my thoughts in writing since I said I would. This
experience seeing how other industries work has been super fun for me. I might
try to find some other jobs to check out as well in the future.
|
var hb = require('handlebars')
, fs = require('vinyl-fs')
, map = require('vinyl-map')
module.exports = function (opts, cb) {
if (!opts || typeof opts === 'function') throw new Error('opts is required')
if (!opts.origin) throw new Error('opts.origin is required')
if (!opts.target) throw new Error('opts.target is required')
if (!opts.context) throw new Error('opts.context is required')
var render = map(function (code, filename) {
var t = hb.compile(code.toString())
return t(opts.context)
})
|
package boun.swe573.accessbadger;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class ABHelloWorld {
@RequestMapping("/welcome")
public String helloWorld() {
String message = "<br><div style='text-align:center;'>"
+ "<h3>********** Hello World **********</div><br><br>";
return message;
}
}
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <csignal>
#include <cstdio>
#include <math.h>
#include <limits>
#include <thread>
#include <chrono>
#include <memory>
#include <sys/stat.h>
#include <ros/ros.h>
#include <nodelet/nodelet.h>
#include <sensor_msgs/Image.h>
#include <sensor_msgs/CameraInfo.h>
#include <sensor_msgs/distortion_models.h>
#include <sensor_msgs/image_encodings.h>
#include <image_transport/image_transport.h>
#include <dynamic_reconfigure/server.h>
#include <autobot/AutobotConfig.h>
#include <nav_msgs/Odometry.h>
#include <tf2/LinearMath/Quaternion.h>
#include <tf2_ros/<API key>.h>
#include <geometry_msgs/TransformStamped.h>
#include <autobot/compound_img.h>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/calib3d/calib3d.hpp>
#include <boost/make_shared.hpp>
#include <boost/thread.hpp>
//#include <sensor_msgs/PointCloud2.h>
//#include <pcl_conversions/pcl_conversions.h>
//#include <pcl/point_cloud.h>
//#include <pcl/point_types.h>
#include <sl/Camera.hpp>
using namespace std;
namespace autobot {
class ZEDWrapperNodelet : public nodelet::Nodelet {
ros::NodeHandle nh;
ros::NodeHandle nh_ns;
boost::shared_ptr<boost::thread> device_poll_thread;
image_transport::Publisher pub_rgb;
image_transport::Publisher pub_raw_rgb;
image_transport::Publisher pub_left;
image_transport::Publisher pub_raw_left;
image_transport::Publisher pub_right;
image_transport::Publisher pub_raw_right;
image_transport::Publisher pub_depth;
ros::Publisher pub_compound_img;
ros::Publisher pub_cloud;
ros::Publisher pub_rgb_cam_info;
ros::Publisher pub_left_cam_info;
ros::Publisher pub_right_cam_info;
ros::Publisher pub_depth_cam_info;
ros::Publisher pub_odom;
tf2_ros::<API key> <API key>;
std::string left_frame_id;
std::string right_frame_id;
std::string rgb_frame_id;
std::string depth_frame_id;
std::string cloud_frame_id;
std::string odometry_frame_id;
std::string <API key>;
// Launch file parameters
int resolution;
int quality;
int sensing_mode;
int rate;
int gpu_id;
int zed_id;
std::string odometry_DB;
std::string svo_filepath;
//Tracking variables
sl::Pose pose;
// zed object
sl::InitParameters param;
std::unique_ptr<sl::Camera> zed;
// flags
int confidence;
bool computeDepth;
bool grabbing = false;
int openniDepthMode = 0;
// Point cloud variables
//sl::Mat cloud;
//string <API key> = "";
//ros::Time point_cloud_time;
/* \brief Convert an sl:Mat to a cv::Mat
* \param mat : the sl::Mat to convert
*/
cv::Mat toCVMat(sl::Mat &mat) {
if (mat.getMemoryType() == sl::MEM_GPU)
mat.updateCPUfromGPU();
int cvType;
switch (mat.getDataType()) {
case sl::MAT_TYPE_32F_C1:
cvType = CV_32FC1;
break;
case sl::MAT_TYPE_32F_C2:
cvType = CV_32FC2;
break;
case sl::MAT_TYPE_32F_C3:
cvType = CV_32FC3;
break;
case sl::MAT_TYPE_32F_C4:
cvType = CV_32FC4;
break;
case sl::MAT_TYPE_8U_C1:
cvType = CV_8UC1;
break;
case sl::MAT_TYPE_8U_C2:
cvType = CV_8UC2;
break;
case sl::MAT_TYPE_8U_C3:
cvType = CV_8UC3;
break;
case sl::MAT_TYPE_8U_C4:
cvType = CV_8UC4;
break;
}
return cv::Mat((int) mat.getHeight(), (int) mat.getWidth(), cvType, mat.getPtr<sl::uchar1>(sl::MEM_CPU), mat.getStepBytes(sl::MEM_CPU));
}
/* \brief Test if a file exist
* \param name : the path to the file
*/
bool file_exist(const std::string& name) {
struct stat buffer;
return (stat(name.c_str(), &buffer) == 0);
}
/* \brief Image to ros message conversion
* \param img : the image to publish
* \param encodingType : the sensor_msgs::image_encodings encoding type
* \param frameId : the id of the reference frame of the image
* \param t : the ros::Time to stamp the image
*/
sensor_msgs::ImagePtr imageToROSmsg(cv::Mat img, const std::string encodingType, std::string frameId, ros::Time t) {
sensor_msgs::ImagePtr ptr = boost::make_shared<sensor_msgs::Image>();
sensor_msgs::Image& imgMessage = *ptr;
imgMessage.header.stamp = t;
imgMessage.header.frame_id = frameId;
imgMessage.height = img.rows;
imgMessage.width = img.cols;
imgMessage.encoding = encodingType;
int num = 1; //for endianness detection
imgMessage.is_bigendian = !(*(char *) &num == 1);
imgMessage.step = img.cols * img.elemSize();
size_t size = imgMessage.step * img.rows;
imgMessage.data.resize(size);
if (img.isContinuous())
memcpy((char*) (&imgMessage.data[0]), img.data, size);
else {
uchar* opencvData = img.data;
uchar* rosData = (uchar*) (&imgMessage.data[0]);
for (unsigned int i = 0; i < img.rows; i++) {
memcpy(rosData, opencvData, imgMessage.step);
rosData += imgMessage.step;
opencvData += img.step;
}
}
return ptr;
}
/* \brief Publish the pose of the camera with a ros Publisher
* \param pose : the 4x4 matrix representing the camera pose
* \param pub_odom : the publisher object to use
* \param odom_frame_id : the id of the reference frame of the pose
* \param t : the ros::Time to stamp the image
*/
//void publishOdom(sl::Pose pose, ros::Publisher &pub_odom, string odom_frame_id, ros::Time t) {
//nav_msgs::Odometry odom;
//odom.header.stamp = t;
//odom.header.frame_id = odom_frame_id;
/odom.child_frame_id = "zed_optical_frame";
//sl::Translation translation = pose.getTranslation();
//odom.pose.pose.position.x = translation(2);
//odom.pose.pose.position.y = -translation(0);
//odom.pose.pose.position.z = -translation(1);
//sl::Orientation quat = pose.getOrientation();
//odom.pose.pose.orientation.x = quat(2);
//odom.pose.pose.orientation.y = -quat(0);
//odom.pose.pose.orientation.z = -quat(1);
//odom.pose.pose.orientation.w = quat(3);
//pub_odom.publish(odom);
/* \brief Publish the pose of the camera as a transformation
* \param pose : the 4x4 matrix representing the camera pose
* \param trans_br : the <API key> object to use
* \param <API key> : the id of the transformation
* \param t : the ros::Time to stamp the image
*/
//void publishTrackedFrame(sl::Pose pose, tf2_ros::<API key> &trans_br, string <API key>, ros::Time t) {
//geometry_msgs::TransformStamped transformStamped;
//transformStamped.header.stamp = ros::Time::now();
//transformStamped.header.frame_id = "zed_initial_frame";
//transformStamped.child_frame_id = <API key>;
//sl::Translation translation = pose.getTranslation();
//transformStamped.transform.translation.x = translation(2);
//transformStamped.transform.translation.y = -translation(0);
//transformStamped.transform.translation.z = -translation(1);
//sl::Orientation quat = pose.getOrientation();
//transformStamped.transform.rotation.x = quat(2);
//transformStamped.transform.rotation.y = -quat(0);
//transformStamped.transform.rotation.z = -quat(1);
//transformStamped.transform.rotation.w = quat(3);
//trans_br.sendTransform(transformStamped);
/* \brief Publish a cv::Mat image with a ros Publisher
* \param img : the image to publish
* \param pub_img : the publisher object to use
* \param img_frame_id : the id of the reference frame of the image
* \param t : the ros::Time to stamp the image
*/
void publishImage(cv::Mat img, image_transport::Publisher &pub_img, string img_frame_id, ros::Time t) {
pub_img.publish(imageToROSmsg(img, sensor_msgs::image_encodings::BGR8, img_frame_id, t));
}
/* \brief Publish a cv::Mat depth image with a ros Publisher
* \param depth : the depth image to publish
* \param pub_depth : the publisher object to use
* \param depth_frame_id : the id of the reference frame of the depth image
* \param t : the ros::Time to stamp the depth image
*/
void publishDepth(cv::Mat depth, image_transport::Publisher &pub_depth, string depth_frame_id, ros::Time t) {
string encoding;
if (openniDepthMode) {
depth *= 1000.0f;
depth.convertTo(depth, CV_16UC1); // in mm, rounded
encoding = sensor_msgs::image_encodings::TYPE_16UC1;
} else {
encoding = sensor_msgs::image_encodings::TYPE_32FC1;
}
pub_depth.publish(imageToROSmsg(depth, encoding, depth_frame_id, t));
}
void <API key>(cv::Mat img, cv::Mat depth, ros::Publisher &pub_compound_img, string img_frame_id, string depth_frame_id, ros::Time t) {
string encoding;
if (openniDepthMode) {
depth *= 1000.0f;
depth.convertTo(depth, CV_16UC1); // in mm, rounded
encoding = sensor_msgs::image_encodings::TYPE_16UC1;
} else {
encoding = sensor_msgs::image_encodings::TYPE_32FC1;
}
sensor_msgs::ImagePtr img_msg = imageToROSmsg(img, sensor_msgs::image_encodings::BGR8, img_frame_id, t);
sensor_msgs::ImagePtr depth_msg = imageToROSmsg(depth, encoding, depth_frame_id, t);
boost::shared_ptr<autobot::compound_img> comp_img = boost::make_shared<autobot::compound_img>();;
comp_img->img = *img_msg.get();
comp_img->depthImg = *depth_msg.get();
pub_compound_img.publish<autobot::compound_img>(comp_img);
}
/* \brief Publish a pointCloud with a ros Publisher
* \param width : the width of the point cloud
* \param height : the height of the point cloud
* \param pub_cloud : the publisher object to use
void publishPointCloud(int width, int height, ros::Publisher &pub_cloud) {
pcl::PointCloud<pcl::PointXYZRGB> point_cloud;
point_cloud.width = width;
point_cloud.height = height;
int size = width*height;
point_cloud.points.resize(size);
sl::Vector4<float>* cpu_cloud = cloud.getPtr<sl::float4>();
for (int i = 0; i < size; i++) {
point_cloud.points[i].x = cpu_cloud[i][2];
point_cloud.points[i].y = -cpu_cloud[i][0];
point_cloud.points[i].z = -cpu_cloud[i][1];
point_cloud.points[i].rgb = cpu_cloud[i][3];
}
sensor_msgs::PointCloud2 output;
pcl::toROSMsg(point_cloud, output); // Convert the point cloud to a ROS message
output.header.frame_id = <API key>; // Set the header values of the ROS message
output.header.stamp = point_cloud_time;
output.height = height;
output.width = width;
output.is_bigendian = false;
output.is_dense = false;
pub_cloud.publish(output);
}
*/
/* \brief Publish the informations of a camera with a ros Publisher
* \param cam_info_msg : the information message to publish
* \param pub_cam_info : the publisher object to use
* \param t : the ros::Time to stamp the message
*/
void publishCamInfo(sensor_msgs::CameraInfoPtr cam_info_msg, ros::Publisher pub_cam_info, ros::Time t) {
static int seq = 0;
cam_info_msg->header.stamp = t;
cam_info_msg->header.seq = seq;
pub_cam_info.publish(cam_info_msg);
seq++;
}
/* \brief Get the information of the ZED cameras and store them in an information message
* \param zed : the sl::zed::Camera* pointer to an instance
* \param left_cam_info_msg : the information message to fill with the left camera informations
* \param right_cam_info_msg : the information message to fill with the right camera informations
* \param left_frame_id : the id of the reference frame of the left camera
* \param right_frame_id : the id of the reference frame of the right camera
*/
void fillCamInfo(sl::Camera* zed, sensor_msgs::CameraInfoPtr left_cam_info_msg, sensor_msgs::CameraInfoPtr right_cam_info_msg,
string left_frame_id, string right_frame_id) {
int width = zed->getResolution().width;
int height = zed->getResolution().height;
sl::CameraInformation zedParam = zed-><API key>();
float baseline = zedParam.<API key>.T[0] * 0.001; // baseline converted in meters
float fx = zedParam.<API key>.left_cam.fx;
float fy = zedParam.<API key>.left_cam.fy;
float cx = zedParam.<API key>.left_cam.cx;
float cy = zedParam.<API key>.left_cam.cy;
// There is no distorsions since the images are rectified
double k1 = 0;
double k2 = 0;
double k3 = 0;
double p1 = 0;
double p2 = 0;
left_cam_info_msg->distortion_model = sensor_msgs::distortion_models::PLUMB_BOB;
right_cam_info_msg->distortion_model = sensor_msgs::distortion_models::PLUMB_BOB;
left_cam_info_msg->D.resize(5);
right_cam_info_msg->D.resize(5);
left_cam_info_msg->D[0] = right_cam_info_msg->D[0] = k1;
left_cam_info_msg->D[1] = right_cam_info_msg->D[1] = k2;
left_cam_info_msg->D[2] = right_cam_info_msg->D[2] = k3;
left_cam_info_msg->D[3] = right_cam_info_msg->D[3] = p1;
left_cam_info_msg->D[4] = right_cam_info_msg->D[4] = p2;
left_cam_info_msg->K.fill(0.0);
right_cam_info_msg->K.fill(0.0);
left_cam_info_msg->K[0] = right_cam_info_msg->K[0] = fx;
left_cam_info_msg->K[2] = right_cam_info_msg->K[2] = cx;
left_cam_info_msg->K[4] = right_cam_info_msg->K[4] = fy;
left_cam_info_msg->K[5] = right_cam_info_msg->K[5] = cy;
left_cam_info_msg->K[8] = right_cam_info_msg->K[8] = 1.0;
left_cam_info_msg->R.fill(0.0);
right_cam_info_msg->R.fill(0.0);
left_cam_info_msg->P.fill(0.0);
right_cam_info_msg->P.fill(0.0);
left_cam_info_msg->P[0] = right_cam_info_msg->P[0] = fx;
left_cam_info_msg->P[2] = right_cam_info_msg->P[2] = cx;
left_cam_info_msg->P[5] = right_cam_info_msg->P[5] = fy;
left_cam_info_msg->P[6] = right_cam_info_msg->P[6] = cy;
left_cam_info_msg->P[10] = right_cam_info_msg->P[10] = 1.0;
right_cam_info_msg->P[3] = (-1 * fx * baseline);
left_cam_info_msg->width = right_cam_info_msg->width = width;
left_cam_info_msg->height = right_cam_info_msg->height = height;
left_cam_info_msg->header.frame_id = left_frame_id;
right_cam_info_msg->header.frame_id = right_frame_id;
}
void callback(autobot::AutobotConfig &config, uint32_t level) {
NODELET_INFO("Reconfigure confidence : %d", config.confidence);
confidence = config.confidence;
}
void device_poll() {
ros::Rate loop_rate(rate);
ros::Time old_t = ros::Time::now();
bool old_image = false;
bool tracking_activated = false;
// Get the parameters of the ZED images
int width = zed->getResolution().width;
int height = zed->getResolution().height;
<API key>("Image size : " << width << "x" << height);
cv::Size cvSize(width, height);
cv::Mat leftImRGB(cvSize, CV_8UC3);
cv::Mat rightImRGB(cvSize, CV_8UC3);
// Create and fill the camera information messages
//sensor_msgs::CameraInfoPtr rgb_cam_info_msg(new sensor_msgs::CameraInfo());
sensor_msgs::CameraInfoPtr left_cam_info_msg(new sensor_msgs::CameraInfo());
sensor_msgs::CameraInfoPtr right_cam_info_msg(new sensor_msgs::CameraInfo());
sensor_msgs::CameraInfoPtr depth_cam_info_msg(new sensor_msgs::CameraInfo());
fillCamInfo(zed.get(), left_cam_info_msg, right_cam_info_msg, left_frame_id, right_frame_id);
//rgb_cam_info_msg = depth_cam_info_msg = left_cam_info_msg; // the reference camera is the Left one (next to the ZED logo)
sl::RuntimeParameters runParams;
runParams.sensing_mode = static_cast<sl::SENSING_MODE> (sensing_mode);
sl::TrackingParameters trackParams;
trackParams.area_file_path = odometry_DB.c_str();
sl::Mat leftZEDMat, rightZEDMat, depthZEDMat;
// Main loop
while (nh_ns.ok()) {
// Check for subscribers
int rgb_SubNumber = pub_rgb.getNumSubscribers();
int rgb_raw_SubNumber = pub_raw_rgb.getNumSubscribers();
int left_SubNumber = pub_left.getNumSubscribers();
int left_raw_SubNumber = pub_raw_left.getNumSubscribers();
int right_SubNumber = pub_right.getNumSubscribers();
int right_raw_SubNumber = pub_raw_right.getNumSubscribers();
int depth_SubNumber = pub_depth.getNumSubscribers();
int compound_SubNumber = pub_compound_img.getNumSubscribers();
int cloud_SubNumber = pub_cloud.getNumSubscribers();
int odom_SubNumber = pub_odom.getNumSubscribers();
bool runLoop = (rgb_SubNumber + rgb_raw_SubNumber + left_SubNumber + left_raw_SubNumber + right_SubNumber + right_raw_SubNumber + depth_SubNumber + cloud_SubNumber + odom_SubNumber) > 0;
runParams.enable_point_cloud = false;
if (cloud_SubNumber > 0)
runParams.enable_point_cloud = true;
ros::Time t = ros::Time::now(); // Get current time
// Run the loop only if there is some subscribers
if (true) {
if (odom_SubNumber > 0 && !tracking_activated) { //Start the tracking
if (odometry_DB != "" && !file_exist(odometry_DB)) {
odometry_DB = "";
NODELET_WARN("odometry_DB path doesn't exist or is unreachable.");
}
zed->enableTracking(trackParams);
tracking_activated = true;
} else if (odom_SubNumber == 0 && tracking_activated) { //Stop the tracking
zed->disableTracking();
tracking_activated = false;
}
computeDepth = (depth_SubNumber + cloud_SubNumber + odom_SubNumber) > 0; // Detect if one of the subscriber need to have the depth information
grabbing = true;
if (computeDepth) {
int actual_confidence = zed-><API key>();
if (actual_confidence != confidence)
zed-><API key>(confidence);
runParams.enable_depth = true; // Ask to compute the depth
} else
runParams.enable_depth = false;
old_image = zed->grab(runParams); // Ask to not compute the depth
grabbing = false;
if (old_image) { // Detect if a error occurred (for example: the zed have been disconnected) and re-initialize the ZED
NODELET_DEBUG("Wait for a new image to proceed");
std::this_thread::sleep_for(std::chrono::milliseconds(2));
if ((t - old_t).toSec() > 5) {
// delete the old object before constructing a new one
zed.reset();
zed.reset(new sl::Camera());
NODELET_INFO("Re-openning the ZED");
sl::ERROR_CODE err = sl::<API key>;
while (err != sl::SUCCESS) {
err = zed->open(param); // Try to initialize the ZED
NODELET_INFO_STREAM(errorCode2str(err));
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
}
tracking_activated = false;
if (odom_SubNumber > 0) { //Start the tracking
if (odometry_DB != "" && !file_exist(odometry_DB)) {
odometry_DB = "";
NODELET_WARN("odometry_DB path doesn't exist or is unreachable.");
}
zed->enableTracking(trackParams);
tracking_activated = true;
}
}
continue;
}
old_t = ros::Time::now();
// Publish the left == rgb image if someone has subscribed to
if (left_SubNumber > 0 || rgb_SubNumber > 0) {
// Retrieve RGBA Left image
zed->retrieveImage(leftZEDMat, sl::VIEW_LEFT);
cv::cvtColor(toCVMat(leftZEDMat), leftImRGB, CV_RGBA2RGB);
if (left_SubNumber > 0) {
publishCamInfo(left_cam_info_msg, pub_left_cam_info, t);
publishImage(leftImRGB, pub_left, left_frame_id, t);
}
//if (rgb_SubNumber > 0) {
//publishCamInfo(rgb_cam_info_msg, pub_rgb_cam_info, t);
//publishImage(leftImRGB, pub_rgb, rgb_frame_id, t); // rgb is the left image
}
// Publish the left_raw == rgb_raw image if someone has subscribed to
//if (left_raw_SubNumber > 0 || rgb_raw_SubNumber > 0) {
/ Retrieve RGBA Left image
//zed->retrieveImage(leftZEDMat, sl::<API key>);
//cv::cvtColor(toCVMat(leftZEDMat), leftImRGB, CV_RGBA2RGB);
//if (left_raw_SubNumber > 0) {
//publishCamInfo(left_cam_info_msg, pub_left_cam_info, t);
//publishImage(leftImRGB, pub_raw_left, left_frame_id, t);
//if (rgb_raw_SubNumber > 0) {
//publishCamInfo(rgb_cam_info_msg, pub_rgb_cam_info, t);
//publishImage(leftImRGB, pub_raw_rgb, rgb_frame_id, t);
// Publish the right image if someone has subscribed to
if (right_SubNumber > 0) {
// Retrieve RGBA Right image
zed->retrieveImage(rightZEDMat, sl::VIEW_RIGHT);
cv::cvtColor(toCVMat(rightZEDMat), rightImRGB, CV_RGBA2RGB);
publishCamInfo(right_cam_info_msg, pub_right_cam_info, t);
publishImage(rightImRGB, pub_right, right_frame_id, t);
}
// Publish the right image if someone has subscribed to
//if (right_raw_SubNumber > 0) {
/ Retrieve RGBA Right image
//zed->retrieveImage(rightZEDMat, sl::<API key>);
//cv::cvtColor(toCVMat(rightZEDMat), rightImRGB, CV_RGBA2RGB);
//publishCamInfo(right_cam_info_msg, pub_right_cam_info, t);
//publishImage(rightImRGB, pub_raw_right, right_frame_id, t);
//Publish the depth image if someone has subscribed to
//if (depth_SubNumber > 0) {
if (depth_SubNumber > 0) {
zed->retrieveMeasure(depthZEDMat, sl::MEASURE_DEPTH);
publishCamInfo(depth_cam_info_msg, pub_depth_cam_info, t);
publishDepth(toCVMat(depthZEDMat), pub_depth, depth_frame_id, t); // in meters
}
// subscription-based publishing not working with vanilla ros::publisher so turning off
// for compound image
// if (compound_SubNumber > 0) {
zed->retrieveImage(leftZEDMat, sl::VIEW_LEFT);
cv::cvtColor(toCVMat(leftZEDMat), leftImRGB, CV_RGBA2RGB);
zed->retrieveMeasure(depthZEDMat, sl::MEASURE_DEPTH);
<API key>(leftImRGB, toCVMat(depthZEDMat), pub_compound_img, left_frame_id, depth_frame_id, t); // in meters
// Publish the point cloud if someone has subscribed to
//if (cloud_SubNumber > 0) {
/ Run the point cloud convertion asynchronously to avoid slowing down all the program
/ Retrieve raw pointCloud data
//zed->retrieveMeasure(cloud, sl::MEASURE_XYZBGRA);
//<API key> = cloud_frame_id;
//point_cloud_time = t;
//publishPointCloud(width, height, pub_cloud);
// Publish the odometry if someone has subscribed to
//if (odom_SubNumber > 0) {
//zed->getPosition(pose);
//publishOdom(pose, pub_odom, odometry_frame_id, t);
//Note, the frame is published, but its values will only change if someone has subscribed to odom
//publishTrackedFrame(pose, <API key>, <API key>, t); //publish the tracked Frame
loop_rate.sleep();
} else {
//publishTrackedFrame(pose, <API key>, <API key>, ros::Time::now()); //publish the tracked Frame before the sleep
std::this_thread::sleep_for(std::chrono::milliseconds(10)); // No subscribers, we just wait
}
} // while loop
zed.reset();
}
void onInit() {
// Launch file parameters
resolution = sl::RESOLUTION_HD720;
quality = sl::<API key>;
//sensing_mode = sl::<API key>;
sensing_mode = sl::SENSING_MODE_FILL;
rate = 30;
gpu_id = -1;
zed_id = 0;
odometry_DB = "";
std::string img_topic = "image_rect_color";
std::string img_raw_topic = "image_raw_color";
// Set the default topic names
string rgb_topic = "rgb/" + img_topic;
string rgb_raw_topic = "rgb/" + img_raw_topic;
string rgb_cam_info_topic = "rgb/camera_info";
rgb_frame_id = "/zed_current_frame";
string left_topic = "left/" + img_topic;
string left_raw_topic = "left/" + img_raw_topic;
string left_cam_info_topic = "left/camera_info";
left_frame_id = "/zed_current_frame";
string right_topic = "right/" + img_topic;
string right_raw_topic = "right/" + img_raw_topic;
string <API key> = "right/camera_info";
right_frame_id = "/zed_current_frame";
string depth_topic = "depth/";
if (openniDepthMode)
depth_topic += "<API key>";
else
depth_topic += "depth_registered";
string compound_topic = "compound_img/";
string <API key> = "depth/camera_info";
depth_frame_id = "/zed_depth_frame";
string point_cloud_topic = "point_cloud/cloud_registered";
cloud_frame_id = "/zed_current_frame";
string odometry_topic = "odom";
odometry_frame_id = "/zed_initial_frame";
<API key> = "/zed_current_frame";
nh = getMTNodeHandle();
nh_ns = <API key>();
// Get parameters from launch file
nh_ns.getParam("resolution", resolution);
nh_ns.getParam("quality", quality);
nh_ns.getParam("sensing_mode", sensing_mode);
nh_ns.getParam("frame_rate", rate);
nh_ns.getParam("odometry_DB", odometry_DB);
nh_ns.getParam("openni_depth_mode", openniDepthMode);
nh_ns.getParam("gpu_id", gpu_id);
nh_ns.getParam("zed_id", zed_id);
if (openniDepthMode)
NODELET_INFO_STREAM("Openni depth mode activated");
nh_ns.getParam("rgb_topic", rgb_topic);
nh_ns.getParam("rgb_raw_topic", rgb_raw_topic);
nh_ns.getParam("rgb_cam_info_topic", rgb_cam_info_topic);
nh_ns.getParam("left_topic", left_topic);
nh_ns.getParam("left_raw_topic", left_raw_topic);
nh_ns.getParam("left_cam_info_topic", left_cam_info_topic);
nh_ns.getParam("right_topic", right_topic);
nh_ns.getParam("right_raw_topic", right_raw_topic);
nh_ns.getParam("<API key>", <API key>);
nh_ns.getParam("depth_topic", depth_topic);
nh_ns.getParam("<API key>", <API key>);
nh_ns.getParam("point_cloud_topic", point_cloud_topic);
nh_ns.getParam("odometry_topic", odometry_topic);
nh_ns.param<std::string>("svo_filepath", svo_filepath, std::string());
// Create the ZED object
zed.reset(new sl::Camera());
// Try to initialize the ZED
if (!svo_filepath.empty())
param.svo_input_filename = svo_filepath.c_str();
else {
param.camera_fps = rate;
param.camera_resolution = static_cast<sl::RESOLUTION> (resolution);
param.camera_linux_id = zed_id;
}
param.coordinate_units = sl::UNIT_METER;
param.coordinate_system = sl::<API key>;
param.depth_mode = static_cast<sl::DEPTH_MODE> (quality);
param.sdk_verbose = true;
param.sdk_gpu_id = gpu_id;
sl::ERROR_CODE err = sl::<API key>;
while (err != sl::SUCCESS) {
err = zed->open(param);
NODELET_INFO_STREAM(errorCode2str(err));
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
}
cout << "ZED OPENED" << endl;
//ERRCODE display
dynamic_reconfigure::Server<autobot::AutobotConfig> server;
dynamic_reconfigure::Server<autobot::AutobotConfig>::CallbackType f;
f = boost::bind(&ZEDWrapperNodelet::callback, this, _1, _2);
server.setCallback(f);
confidence = 80;
// Create all the publishers
// Image publishers
image_transport::ImageTransport it_zed(nh);
//pub_rgb = it_zed.advertise(rgb_topic, 1); //rgb
//NODELET_INFO_STREAM("Advertized on topic " << rgb_topic);
//pub_raw_rgb = it_zed.advertise(rgb_raw_topic, 1); //rgb raw
//NODELET_INFO_STREAM("Advertized on topic " << rgb_raw_topic);
pub_left = it_zed.advertise(left_topic, 2); //left
NODELET_INFO_STREAM("Advertized on topic " << left_topic);
//pub_raw_left = it_zed.advertise(left_raw_topic, 1); //left raw
//NODELET_INFO_STREAM("Advertized on topic " << left_raw_topic);
pub_right = it_zed.advertise(right_topic, 2); //right
NODELET_INFO_STREAM("Advertized on topic " << right_topic);
//pub_raw_right = it_zed.advertise(right_raw_topic, 1); //right raw
//NODELET_INFO_STREAM("Advertized on topic " << right_raw_topic);
pub_depth = it_zed.advertise(depth_topic, 2); //depth
NODELET_INFO_STREAM("Advertized on topic " << depth_topic);
pub_compound_img = nh.advertise<autobot::compound_img>(compound_topic, 2); //depth
NODELET_INFO_STREAM("Advertized on topic " << compound_topic);
/PointCloud publisher
//pub_cloud = nh.advertise<sensor_msgs::PointCloud2> (point_cloud_topic, 1);
//NODELET_INFO_STREAM("Advertized on topic " << point_cloud_topic);
// Camera info publishers
//pub_rgb_cam_info = nh.advertise<sensor_msgs::CameraInfo>(rgb_cam_info_topic, 1); //rgb
//NODELET_INFO_STREAM("Advertized on topic " << rgb_cam_info_topic);
pub_left_cam_info = nh.advertise<sensor_msgs::CameraInfo>(left_cam_info_topic, 1); //left
NODELET_INFO_STREAM("Advertized on topic " << left_cam_info_topic);
pub_right_cam_info = nh.advertise<sensor_msgs::CameraInfo>(<API key>, 1); //right
NODELET_INFO_STREAM("Advertized on topic " << <API key>);
pub_depth_cam_info = nh.advertise<sensor_msgs::CameraInfo>(<API key>, 1); //depth
NODELET_INFO_STREAM("Advertized on topic " << <API key>);
//Odometry publisher
//pub_odom = nh.advertise<nav_msgs::Odometry>(odometry_topic, 1);
//NODELET_INFO_STREAM("Advertized on topic " << odometry_topic);
device_poll_thread = boost::shared_ptr<boost::thread>
(new boost::thread(boost::bind(&ZEDWrapperNodelet::device_poll, this)));
}
}; // class <API key>
} // namespace
#include <pluginlib/class_list_macros.h>
<API key>(autobot::ZEDWrapperNodelet, nodelet::Nodelet);
|
# <API key>: true
# == Schema Information
# Table name: tags
# id :uuid not null, primary key
# shared :boolean not null
# tag_name :string not null
# created_at :datetime not null
# updated_at :datetime not null
# organization_id :bigint not null
# Indexes
# <API key> (organization_id)
FactoryBot.define do
factory :tag do
tag_name { Faker::Games::Pokemon.name }
organization { create :organization }
shared { true }
end
end
|
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>class <API key> - RDoc Documentation</title>
<script type="text/javascript">
var rdoc_rel_prefix = "./";
</script>
<script src="./js/jquery.js"></script>
<script src="./js/darkfish.js"></script>
<link href="./css/fonts.css" rel="stylesheet">
<link href="./css/rdoc.css" rel="stylesheet">
<body id="top" role="document" class="class">
<nav role="navigation">
<div id="project-navigation">
<div id="home-section" role="region" title="Quick navigation" class="nav-section">
<h2>
<a href="./index.html" rel="home">Home</a>
</h2>
<div id="<API key>">
<a href="./table_of_contents.html#pages">Pages</a>
<a href="./table_of_contents.html#classes">Classes</a>
<a href="./table_of_contents.html#methods">Methods</a>
</div>
</div>
<div id="search-section" role="search" class="project-section initially-hidden">
<form action="#" method="get" accept-charset="utf-8">
<div id="<API key>">
<input id="search-field" role="combobox" aria-label="Search"
aria-autocomplete="list" aria-controls="search-results"
type="text" name="search" placeholder="Search" spellcheck="false"
title="Type to search, Up and Down to navigate, Enter to load">
</div>
<ul id="search-results" aria-label="Search Results"
aria-busy="false" aria-expanded="false"
aria-atomic="false" class="initially-hidden"></ul>
</form>
</div>
</div>
<div id="class-metadata">
<div id="<API key>" class="nav-section">
<h3>Parent</h3>
<p class="link">ActiveRecord::Migration
</div>
<!-- Method Quickref -->
<div id="method-list-section" class="nav-section">
<h3>Methods</h3>
<ul class="link-list" role="directory">
<li ><a href="#method-c-down">::down</a>
<li ><a href="#method-c-up">::up</a>
</ul>
</div>
</div>
</nav>
<main role="main" aria-labelledby="<API key>">
<h1 id="<API key>" class="class">
class <API key>
</h1>
<section class="description">
</section>
<section id="5Buntitled-5D" class="<API key>">
<section id="<API key>" class="method-section">
<header>
<h3>Public Class Methods</h3>
</header>
<div id="method-c-down" class="method-detail ">
<div class="method-heading">
<span class="method-name">down</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="down-source">
<pre><span class="ruby-comment"># File db/migrate/<API key>.rb, line 6</span>
<span class="ruby-keyword">def</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">down</span>
<span class="ruby-identifier">remove_attachment</span> <span class="ruby-value">:speakers</span>, <span class="ruby-value">:photo</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-c-up" class="method-detail ">
<div class="method-heading">
<span class="method-name">up</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="up-source">
<pre><span class="ruby-comment"># File db/migrate/<API key>.rb, line 2</span>
<span class="ruby-keyword">def</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">up</span>
<span class="ruby-identifier">add_attachment</span> <span class="ruby-value">:speakers</span>, <span class="ruby-value">:photo</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
</section>
</section>
</main>
<footer id="validator-badges" role="contentinfo">
<p><a href="http://validator.w3.org/check/referer">Validate</a>
<p>Generated by <a href="http://docs.seattlerb.org/rdoc/">RDoc</a> 4.2.0.
<p>Based on <a href="http:
</footer>
|
<dom-element id="email-reader">
<template>
<!-- <iframe sandbox height="100%" width="100%" srcdoc="{{email.body}}"></iframe> -->
</template>
<script>
Polymer({
is: 'email-reader'
})
</script>
</dom-element>
|
INSERT INTO customers (first_name, last_name) VALUES ('Nobita', 'Nobi');
INSERT INTO customers (first_name, last_name) VALUES ('Takeshi', 'Goda');
INSERT INTO customers (first_name, last_name) VALUES ('Suneo', 'Honekawa');
INSERT INTO customers (first_name, last_name) VALUES ('Shizuka', 'Minamoto');
|
#!/usr/bin/python
# -*- coding: utf-8 -*-
from scrapy.spider import Spider
from scrapy.selector import Selector
from my_settings import name_file, test_mode, difference_days
from datetime import datetime, timedelta
print "Run spider NewenglandFilm"
file_output = open(name_file, 'a')
<API key> = []
email_in_file = open(name_file, 'r').readlines()
if test_mode:
current_date = (datetime.today() - timedelta(days=difference_days)).strftime('%m/%d/%Y')
else:
current_date = datetime.today().strftime('%m/%d/%Y')
class NewenglandFilm(Spider):
name = 'newenglandfilm'
allowed_domains = ["newenglandfilm.com"]
start_urls = ["http://newenglandfilm.com/jobs.htm"]
def parse(self, response):
sel = Selector(response)
for num_div in xrange(1, 31):
|
module Tabulo
# @!visibility private
module Util
NEWLINE = /\r\n|\n|\r/
# @!visibility private
def self.condense_lines(lines)
join_lines(lines.reject(&:empty?))
end
# @!visibility private
def self.divides?(smaller, larger)
larger % smaller == 0
end
# @!visibility private
def self.join_lines(lines)
lines.join($/)
end
# @!visibility private
def self.max(x, y)
x > y ? x : y
end
# @!visibility private
def self.slice_hash(hash, *keys)
new_hash = {}
keys.each { |k| new_hash[k] = hash[k] if hash.include?(k) }
new_hash
end
# @!visibility private
# @return [Integer] the length of the longest segment of str when split by newlines
def self.wrapped_width(str)
return 0 if str.empty?
segments = str.split(NEWLINE)
segments.inject(1) do |<API key>, segment|
Util.max(<API key>, Unicode::DisplayWidth.of(segment))
end
end
end
end
|
<?php
//Get Variables
$favuserid = $_POST['userid'];
$ownprofile = $_POST['ownprofile'];
$ownusername = $_POST['ownusername'];
//Connect to mysql database
$connection = mysql_connect("localhost", "6470", "6470") or die("mySQL Connection Error<br />\n");
$database='6470_main';
mysql_select_db($database) or die('Error, could not access database '.$database."\n");
//Convert username to id
$result = mysql_query("SELECT * FROM user WHERE username = '$ownusername'") or die(mysql_error());
$row = mysql_fetch_array($result);
$ownuserid = $row['id'];
//Check useruserfav
$result = mysql_query("SELECT * FROM useruserfav WHERE (user1id = '$ownuserid' && user2id = '$favuserid')") or die(mysql_error());
$row = mysql_fetch_array($result);
if($row['id']=='' || $row['id']==null){//Search the other way around
$result = mysql_query("SELECT * FROM useruserfav WHERE (user2id = '$ownuserid' && user1id = '$favuserid')") or die(mysql_error());
$row = mysql_fetch_array($result);
if($row['id']=='' || $row['id']==null){//Not friended yet, become a friend
mysql_query("INSERT INTO useruserfav
(user1id, user2id)
VALUES('$ownuserid','$favuserid')") or die(mysql_error());
echo 'You are now friends with this person. ';
}else{//Already friended, delete friend
$id = $row['id'];
mysql_query("DELETE FROM useruserfav WHERE id='$id'") or die(mysql_error());
echo 'You are no longer friends with this person.';
}
}else{//Already friended, delete friend
$id = $row['id'];
mysql_query("DELETE FROM useruserfav WHERE id='$id'") or die(mysql_error());
echo 'You are no longer friends with this person.';
}
?>
|
var request = require('request');
var url = require('url');
var authenticate = require('./oauthentication');
var Request = function(obj){
this.obj = obj;
};
Request.prototype.mailboxes = function(method, specific_url, params, callback){
/*
* @params:
* @ param : if user wants to call specific mailbox e.g. : /
* @ callback: function to pass the following parameters to:
* @error
* @response
* @body
*/
makeRequest(this, method, 'https://api.slice.com/api/v1/mailboxes', specific_url, params, callback);
};
Request.prototype.users = function(method, specific_url, params, callback){
makeRequest(this, method, 'https://api.slice.com/api/v1/users', specific_url, params, callback);
};
Request.prototype.orders = function(method, specific_url, params, callback){
makeRequest(this, method, 'https://api.slice.com/api/v1/orders', specific_url, params, callback);
};
Request.prototype.items = function(method, specific_url, params, callback){
makeRequest(this, method, 'https://api.slice.com/api/v1/items', specific_url, params, callback);
};
Request.prototype.shipments = function(method, specific_url, params, callback){
makeRequest(this, method, 'https://api.slice.com/api/v1/shipments', specific_url, params, callback);
};
Request.prototype.recalls = function(method, specific_url, params, callback){
makeRequest(this, method, 'https://api.slice.com/api/v1/recalls', specific_url, params, callback);
};
Request.prototype.emails = function(method, specific_url, params, callback){
makeRequest(this, method, 'https://api.slice.com/api/v1/emails', specific_url, params, callback);
};
Request.prototype.merchants = function(method, specific_url, params, callback){
makeRequest(this, method, 'https://api.slice.com/api/v1/merchants', specific_url, params, callback);
};
Request.prototype.actions = function(method, specific_url, params, callback){
makeRequest(this, method, 'https://api.slice.com/api/v1/actions/update', specific_url, params, callback);
};
Request.prototype.setAccessToken = function(access_token){
this.access_token = access_token;
}
var makeRequest = function(obj, method, url, specific_url, params, callback){
this.params = params || '';
this.param_url = compileRequest(this.params);
this.method = method || 'GET'; // defaults to 'GET'
this.specific_url = specific_url || '';
request({
uri : url+this.specific_url+this.params,
headers : {
'Authorization' : 'Bearer ' + obj.access_token
},
method : this.method,
timeout : 1000,
followRedirect : true,
maxRedirects : 4,
}, function(error, response, body){
if(error){
throw error;
}
callback(error, response, body);
});
};
var compileRequest = function(params){
var param_url = '?';
for(var key in params){
param_url += key + '=' + params[key] + '&';
}
return param_url.substring(0, param_url.length-1);
};
module.exports = Request;
module.exports.users = Request.users;
module.exports.mailboxes = Request.mailboxes;
module.exports.orders = Request.orders;
module.exports.items = Request.items;
module.exports.shipments = Request.shipments;
module.exports.recalls = Request.recalls;
module.exports.emails = Request.emails;
module.exports.merchants = Request.merchants;
module.exports.actions = Request.actions;
|
<?php
namespace Sasedev\Commons\SharedBundle\HtmlModel\Tags;
use Sasedev\Commons\SharedBundle\HtmlModel\Attributes\Src;
use Sasedev\Commons\SharedBundle\HtmlModel\Attributes\Type;
use Sasedev\Commons\SharedBundle\HtmlModel\Attributes\Charset;
use Sasedev\Commons\SharedBundle\HtmlModel\Attributes\Defer;
use Sasedev\Commons\SharedBundle\HtmlModel\Attributes\Async;
use Sasedev\Commons\SharedBundle\HtmlModel\HtmlTag;
/**
*
* @author sasedev <seif.salah@gmail.com>
*/
class Script extends HtmlTag
{
/**
*
* @var string
*/
const NAME = 'script';
/**
*
* @var boolean
*/
const SELF_CLOSING = false;
/**
* Constructor
*
* @param Src|string $src
* @param string $type
* @param string $charset
* @param boolean $defer
* @param boolean $async
* @param string $content
*/
public function __construct($src = null, $type = null, $charset = null, $defer = false, $async = false, $content = null)
{
$attributes = array();
if (null != $src) {
if ($src instanceof Src) {
$srcAttribute = $src;
} else {
$srcAttribute = new Src($src);
}
$attributes[] = $srcAttribute;
}
if (null != $type) {
$typeAttribute = new Type($type);
$attributes[] = $typeAttribute;
}
if (null != $charset) {
$charsetAttribute = new Charset($charset);
$attributes[] = $charsetAttribute;
}
if (null != $defer) {
$deferAttribute = new Defer();
$attributes[] = $deferAttribute;
}
if (null != $async) {
$asyncAttribute = new Async();
$attributes[] = $asyncAttribute;
}
parent::__construct(self::NAME, $attributes, self::SELF_CLOSING, $content);
}
}
|
use std::process::{Command,Output};
use std::io;
use tmux::pane::Pane;
use capture::retrieve_capture;
use serde::Serializer;
use serde::ser::Serialize;
// Come back and question the accuracy of windows without names
// that have active, or previous window designations.
static NAME_REGEX: &'static str = r":\s(\w*)[$\*-]?\s+\(";
static ACTIVE_REGEX: &'static str = r"\s.*(\*)\s";
static LAYOUT_REGEX: &'static str = r"\s\[layout\s(.*)\]";
// Example format: "2: vim* (1 panes) [layout b5be,173x42,0,0,1]"
static LIST_FORMAT: &'static str = "'#{window_index}: #{window_name}#{?window_active,*, } (#{window_panes} panes) [layout #{window_layout}]'";
#[derive(Debug, Deserialize)]
pub struct Window {
pub active: bool,
pub layout: String,
pub name: String,
pub panes: Option<Vec<Pane>>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct WindowInner {
pub active: bool,
pub layout: String,
pub panes: Option<Vec<Pane>>,
}
impl Window {
pub fn new<S>(active: bool, layout: S, name: S, panes: Option<Vec<Pane>>) -> Window
where S: Into<String>
{
Window {
active: active,
layout: layout.into(),
name: name.into(),
panes: panes,
}
}
pub fn from_window(panes: Vec<Pane>, w: Window) -> Window {
Window::new(w.active, w.layout, w.name, Some(panes))
}
pub fn from_line(line: &str) -> Option<Window> {
let active = match retrieve_capture(line, ACTIVE_REGEX) {
Some(_) => true,
None => false
};
let layout = match retrieve_capture(line, LAYOUT_REGEX) {
Some(x) => x,
None => return None
};
let name = match retrieve_capture(line, NAME_REGEX) {
Some(x) => x,
None => return None
};
Some(Window::new(active, layout, name, None))
}
pub fn window_list(target: &str) -> Result<Output, io::Error> {
Command::new("tmux")
.args(&["list-windows", "-t", target, "-F", LIST_FORMAT])
.output()
}
}
impl Serialize for Window {
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer
{
let window = WindowInner { active: self.active, layout: self.layout.clone(), panes: self.panes.clone()};
let mut state = try!(serializer.serialize_map(Some(1)));
try!(serializer.serialize_map_key(&mut state, &self.name));
try!(serializer.serialize_map_value(&mut state, window));
serializer.serialize_map_end(state)
}
}
#[cfg(test)]
mod test {
use super::*;
#[test] // Window with name* representing the active window.
fn <API key>() {
let line = "2: vim* (1 panes) [layout b5be,173x42,0,0,1]";
let window = Window::from_line(line);
assert!(window.is_some())
}
#[test] // Window with name- representing the previous active window.
fn <API key>() {
let line = "2: vim- (1 panes) [layout b5be,173x42,0,0,1]";
let window = Window::from_line(line);
assert!(window.is_some())
}
#[test] // Window with name and no designation.
fn <API key>() {
let line = "2: vim (1 panes) [layout b5be,173x42,0,0,1]";
let window = Window::from_line(line);
assert!(window.is_some())
}
#[test] // Window with no name and active.
fn <API key>() {
let line = "2: * (1 panes) [layout b5be,173x42,0,0,1]";
let window = Window::from_line(line);
assert!(window.is_some())
}
#[test] // Window with no name and the previous active window.
fn <API key>() {
let line = "2: - (1 panes) [layout b5be,173x42,0,0,1]";
let window = Window::from_line(line);
assert!(window.is_some())
}
#[test] // Window with blank name
fn <API key>() {
let line = "2: (1 panes) [layout b5be,173x42,0,0,1]";
let window = Window::from_line(line);
assert!(window.is_some())
}
#[test]
fn <API key>() {
let line = "2: (1 panes) [layout b5be,173x42,0,0,1]";
let window = Window::from_line(line);
assert!(window.is_none())
}
#[test]
fn <API key>() {
let line = "2: vim* (1 panes) [layout b5be,173x42,0,0,1]";
let window = Window::from_line(line).unwrap();
assert!(window.active)
}
#[test]
fn <API key>() {
let line = "2: * (1 panes) [layout b5be,173x42,0,0,1]";
let window = Window::from_line(line).unwrap();
assert!(window.active)
}
#[test]
fn <API key>() {
let line = "2: vim* (1 panes) [layout b5be,173x42,0,0,1]";
let window = Window::from_line(line).unwrap();
assert_eq!(window.name, "vim")
}
#[test]
fn <API key>() {
let line = "2: vim* (1 panes) [layout b5be,173x42,0,0,1]";
let window = Window::from_line(line).unwrap();
assert_eq!(window.layout, "b5be,173x42,0,0,1")
}
}
|
package gradebookdata;
/**
* Represents one row of the course table in the GradeBook database
*
* @author Eric Carlton
*
*/
public class Course {
private String name;
private int weight;
private int ID;
/**
* Create a course with all fields filled
*
* @param name
* name of course
* @param weight
* credit hours ( or weight ) of course
* @param ID
* course_ID in course table
*/
public Course(String name, int weight, int ID) {
this.name = name;
this.weight = weight;
this.ID = ID;
}
/**
* Create a generic course
*/
public Course() {
this("no name", 0, -1);
}
public String getName() {
return name;
}
public Integer getWeight() {
return weight;
}
public Integer getID() {
return ID;
}
/**
* Returns a string formatted as:
* course_name
* course_weight hour(s)
*/
@Override
public String toString() {
String result = name + "\n" + weight;
if (weight == 1)
result = result + " hour";
else
result = result + " hours";
return result;
}
}
|
#include "RDom.h"
#include "Util.h"
#include "IROperator.h"
#include "IRPrinter.h"
namespace Halide {
using namespace Internal;
using std::string;
using std::vector;
RVar::operator Expr() const {
if (!min().defined() || !extent().defined()) {
user_error << "Use of undefined RDom dimension: " <<
(name().empty() ? "<unknown>" : name()) << "\n";
}
return Variable::make(Int(32), name(), domain());
}
Expr RVar::min() const {
if (_domain.defined()) {
return _var().min;
} else {
return Expr();
}
}
Expr RVar::extent() const {
if (_domain.defined()) {
return _var().extent;
} else {
return Expr();
}
}
const std::string &RVar::name() const {
if (_domain.defined()) {
return _var().var;
} else {
return _name;
}
}
template <int N>
ReductionDomain build_domain(ReductionVariable (&vars)[N]) {
vector<ReductionVariable> d(&vars[0], &vars[N]);
ReductionDomain dom(d);
return dom;
}
// This just initializes the predefined x, y, z, w members of RDom.
void RDom::init_vars(string name) {
static string var_names[] = { "x", "y", "z", "w" };
const std::vector<ReductionVariable> &dom_vars = dom.domain();
RVar *vars[] = { &x, &y, &z, &w };
for (size_t i = 0; i < sizeof(vars)/sizeof(vars[0]); i++) {
if (i < dom_vars.size()) {
*(vars[i]) = RVar(dom, i);
} else {
*(vars[i]) = RVar(name + "." + var_names[i]);
}
}
}
RDom::RDom(ReductionDomain d) : dom(d) {
if (d.defined()) {
init_vars("");
}
}
// We suffix all RVars with $r to prevent unintentional name matches with pure vars called x, y, z, w.
RDom::RDom(Expr min, Expr extent, string name) {
if (name == "") {
name = make_entity_name(this, "Halide::RDom", 'r');
}
ReductionVariable vars[] = {
{ name + ".x$r", cast<int>(min), cast<int>(extent) },
};
dom = build_domain(vars);
init_vars(name);
}
RDom::RDom(Expr min0, Expr extent0, Expr min1, Expr extent1, string name) {
if (name == "") {
name = make_entity_name(this, "Halide::RDom", 'r');
}
ReductionVariable vars[] = {
{ name + ".x$r", cast<int>(min0), cast<int>(extent0) },
{ name + ".y$r", cast<int>(min1), cast<int>(extent1) },
};
dom = build_domain(vars);
init_vars(name);
}
RDom::RDom(Expr min0, Expr extent0, Expr min1, Expr extent1, Expr min2, Expr extent2, string name) {
if (name == "") {
name = make_entity_name(this, "Halide::RDom", 'r');
}
ReductionVariable vars[] = {
{ name + ".x$r", cast<int>(min0), cast<int>(extent0) },
{ name + ".y$r", cast<int>(min1), cast<int>(extent1) },
{ name + ".z$r", cast<int>(min2), cast<int>(extent2) },
};
dom = build_domain(vars);
init_vars(name);
}
RDom::RDom(Expr min0, Expr extent0, Expr min1, Expr extent1, Expr min2, Expr extent2, Expr min3, Expr extent3,
string name) {
if (name == "") {
name = make_entity_name(this, "Halide::RDom", 'r');
}
ReductionVariable vars[] = {
{ name + ".x$r", cast<int>(min0), cast<int>(extent0) },
{ name + ".y$r", cast<int>(min1), cast<int>(extent1) },
{ name + ".z$r", cast<int>(min2), cast<int>(extent2) },
{ name + ".w$r", cast<int>(min3), cast<int>(extent3) },
};
dom = build_domain(vars);
init_vars(name);
}
RDom::RDom(Expr min0, Expr extent0, Expr min1, Expr extent1, Expr min2, Expr extent2, Expr min3, Expr extent3,
Expr min4, Expr extent4, string name) {
if (name == "") {
name = make_entity_name(this, "Halide::RDom", 'r');
}
ReductionVariable vars[] = {
{ name + ".x$r", cast<int>(min0), cast<int>(extent0) },
{ name + ".y$r", cast<int>(min1), cast<int>(extent1) },
{ name + ".z$r", cast<int>(min2), cast<int>(extent2) },
{ name + ".w$r", cast<int>(min3), cast<int>(extent3) },
{ name + ".4$r", cast<int>(min4), cast<int>(extent4) },
};
dom = build_domain(vars);
init_vars(name);
}
RDom::RDom(Expr min0, Expr extent0, Expr min1, Expr extent1, Expr min2, Expr extent2, Expr min3, Expr extent3,
Expr min4, Expr extent4, Expr min5, Expr extent5, string name) {
if (name == "") {
name = make_entity_name(this, "Halide::RDom", 'r');
}
ReductionVariable vars[] = {
{ name + ".x$r", cast<int>(min0), cast<int>(extent0) },
{ name + ".y$r", cast<int>(min1), cast<int>(extent1) },
{ name + ".z$r", cast<int>(min2), cast<int>(extent2) },
{ name + ".w$r", cast<int>(min3), cast<int>(extent3) },
{ name + ".4$r", cast<int>(min4), cast<int>(extent4) },
{ name + ".5$r", cast<int>(min5), cast<int>(extent5) },
};
dom = build_domain(vars);
init_vars(name);
}
RDom::RDom(Expr min0, Expr extent0, Expr min1, Expr extent1, Expr min2, Expr extent2, Expr min3, Expr extent3,
Expr min4, Expr extent4, Expr min5, Expr extent5, Expr min6, Expr extent6, string name) {
if (name == "") {
name = make_entity_name(this, "Halide::RDom", 'r');
}
ReductionVariable vars[] = {
{ name + ".x$r", cast<int>(min0), cast<int>(extent0) },
{ name + ".y$r", cast<int>(min1), cast<int>(extent1) },
{ name + ".z$r", cast<int>(min2), cast<int>(extent2) },
{ name + ".w$r", cast<int>(min3), cast<int>(extent3) },
{ name + ".4$r", cast<int>(min4), cast<int>(extent4) },
{ name + ".5$r", cast<int>(min5), cast<int>(extent5) },
{ name + ".6$r", cast<int>(min6), cast<int>(extent6) },
};
dom = build_domain(vars);
init_vars(name);
}
RDom::RDom(Expr min0, Expr extent0, Expr min1, Expr extent1, Expr min2, Expr extent2, Expr min3, Expr extent3,
Expr min4, Expr extent4, Expr min5, Expr extent5, Expr min6, Expr extent6, Expr min7, Expr extent7,
string name) {
if (name == "") {
name = make_entity_name(this, "Halide::RDom", 'r');
}
ReductionVariable vars[] = {
{ name + ".x$r", cast<int>(min0), cast<int>(extent0) },
{ name + ".y$r", cast<int>(min1), cast<int>(extent1) },
{ name + ".z$r", cast<int>(min2), cast<int>(extent2) },
{ name + ".w$r", cast<int>(min3), cast<int>(extent3) },
{ name + ".4$r", cast<int>(min4), cast<int>(extent4) },
{ name + ".5$r", cast<int>(min5), cast<int>(extent5) },
{ name + ".6$r", cast<int>(min6), cast<int>(extent6) },
{ name + ".7$r", cast<int>(min7), cast<int>(extent7) },
};
dom = build_domain(vars);
init_vars(name);
}
RDom::RDom(Buffer b) {
static string var_names[] = {"x$r", "y$r", "z$r", "w$r"};
std::vector<ReductionVariable> vars;
for (int i = 0; i < b.dimensions(); i++) {
ReductionVariable var = {
b.name() + "." + var_names[i],
b.min(i),
b.extent(i)
};
vars.push_back(var);
}
dom = ReductionDomain(vars);
init_vars(b.name());
}
RDom::RDom(ImageParam p) {
static string var_names[] = {"x$r", "y$r", "z$r", "w$r"};
std::vector<ReductionVariable> vars;
for (int i = 0; i < p.dimensions(); i++) {
ReductionVariable var = {
p.name() + "." + var_names[i],
p.min(i),
p.extent(i)
};
vars.push_back(var);
}
dom = ReductionDomain(vars);
init_vars(p.name());
}
int RDom::dimensions() const {
return (int)dom.domain().size();
}
RVar RDom::operator[](int i) const {
if (i == 0) return x;
if (i == 1) return y;
if (i == 2) return z;
if (i == 3) return w;
if (i < dimensions()) {
return RVar(dom, i);
}
user_error << "Reduction domain index out of bounds: " << i << "\n";
return x; // Keep the compiler happy
}
RDom::operator Expr() const {
if (dimensions() != 1) {
user_error << "Error: Can't treat this multidimensional RDom as an Expr:\n"
<< (*this) << "\n"
<< "Only single-dimensional RDoms can be cast to Expr.\n";
}
return Expr(x);
}
RDom::operator RVar() const {
if (dimensions() != 1) {
user_error << "Error: Can't treat this multidimensional RDom as an RVar:\n"
<< (*this) << "\n"
<< "Only single-dimensional RDoms can be cast to RVar.\n";
}
return x;
}
/** Emit an RVar in a human-readable form */
std::ostream &operator<<(std::ostream &stream, RVar v) {
stream << v.name() << "(" << v.min() << ", " << v.extent() << ")";
return stream;
}
/** Emit an RDom in a human-readable form. */
std::ostream &operator<<(std::ostream &stream, RDom dom) {
stream << "RDom(\n";
for (int i = 0; i < dom.dimensions(); i++) {
stream << " " << dom[i] << "\n";
}
stream << ")\n";
return stream;
}
}
|
(function () {
'use strict';
angular.module('atacamaApp').directive('atacamaIndicator', indicatorDirective);
function indicatorDirective() {
return {
templateUrl: 'app/components/widgets/indicator/indicator.html',
link: linkFunc,
controller: '<API key>',
controllerAs: 'vm',
bindToController: true // because the scope is isolated
};
}
function linkFunc(scope, element, attrs) {
//set to null by default so images will not try to load until the data is returned
scope.selectedLocation = null;
scope.isLoaded = false;
scope.hasError = false;
// scope.offsetParent = element.offsetParent();
}
})();
|
#ifndef CONFIGURATION_H_
#define CONFIGURATION_H_
#include <string>
#include <vector>
#include <map>
#include <mutex>
namespace daf
{
class Config
{
private:
std::string FileLocation;
std::mutex Lock;
std::map<std::string, std::string> Storage;
public:
Config();
Config(const char* loc);
Config(std::string loc);
virtual ~Config();
std::string& operator[](std::string key);
const std::map<std::string, std::string> getMap();
bool remove(std::string key);
bool refresh();
bool flush();
std::string getFilename();
void setFilename(std::string nloc);
};
// typedef void* DPFDAT;
// class Configuration;
// class ConfigItem;
// enum ConfigType
// Namespace,
// Number,
// String,
// Binary
// enum NumberType
// Integer,
// Floating
// class ConfigItem
// public:
// ConfigType type;
// DPFDAT data;
// class Configuration
// private:
// std::map<std::string, ConfigItem> ConfigItems;
// std::string location;
// public:
// Configuration();
// Configuration(const char* location);
// Configuration(std::string location);
// Configuration(Configuration& configuration);
// Configuration& operator=(Configuration&& configuration);
// virtual ~Configuration();
// bool read();
}
#endif /* CONFIGURATION_H_ */
|
define(['tantaman/web/css_manip/CssManip'],
function(CassManip) {
var el = CassManip.getStyleElem({
id: 'customBackgrounds',
create: true
});
/**
* This is essentially a view class that
* render the stylesheet of background classes whenever
* new background classes are created.
*
* @param {EditorModel} editorModel
*/
function CustomBgStylesheet(editorModel) {
this.model = editorModel;
editorModel.on('change:customBackgrounds', this.render, this);
}
CustomBgStylesheet.prototype = {
/**
* render the stylesheet. Should never
* need to be called explicitly.
*/
render: function(m, customBgs) {
if (!customBgs) return;
el.innerHTML =
JST['strut.<API key>/CustomBgStylesheet'](customBgs.get('bgs'));
},
/**
* Unregister from the model so this component
* can be cleaned up.
*/
dispose: function() {
this.model.off(null, null, this);
}
}
return CustomBgStylesheet;
});
|
import { sp } from "@pnp/sp";
import "@pnp/sp/webs";
import "@pnp/sp/user-custom-actions";
import { ISearchQuery } from "@pnp/sp/search";
import { Web } from "@pnp/sp/webs";
export default class <API key> {
/**
* <API key>
*/
public <API key> = async (webURL: string) => {
let web = Web(webURL);
let response;
try {
response = await web.userCustomActions();
console.log(response);
//let temp = await sp.site.userCustomActions();
//console.log(temp);
} catch (error) {
console.log(error);
response = error;
}
return response;
}
/**
* <API key>
*/
public <API key> = async () => {
let response;
try {
response = await sp.search(<ISearchQuery>{
Querytext: "contentclass:STS_Site",
SelectProperties: ["Title", "SPSiteUrl", "WebTemplate"],
RowLimit: 1000,
TrimDuplicates: true
});
console.log(response.<API key>);
} catch (error) {
console.log(error);
response = error;
}
return response;
}
/**
* <API key>
*/
public <API key> = async (webURL: string | number, selectedID: string, updateJSON: any) => {
let web = Web(webURL as string);
let response;
try {
response = await web.userCustomActions.getById(selectedID).update(updateJSON);
} catch (error) {
console.log(error);
}
}
}
|
#include <common.h>
#include <dm.h>
#include <malloc.h>
#include <sdhci.h>
#include <fdtdec.h>
#include <linux/libfdt.h>
#include <asm/gpio.h>
#include <asm/arch/mmc.h>
#include <asm/arch/clk.h>
#include <errno.h>
#include <asm/arch/pinmux.h>
#ifdef CONFIG_DM_MMC
struct s5p_sdhci_plat {
struct mmc_config cfg;
struct mmc mmc;
};
<API key>;
#endif
static char *S5P_NAME = "SAMSUNG SDHCI";
static void <API key>(struct sdhci_host *host)
{
unsigned long val, ctrl;
/*
* SELCLKPADDS[17:16]
* 00 = 2mA
* 01 = 4mA
* 10 = 7mA
* 11 = 9mA
*/
sdhci_writel(host, <API key>(0x3), SDHCI_CONTROL4);
val = sdhci_readl(host, SDHCI_CONTROL2);
val &= <API key>(3);
val |= <API key> |
<API key> |
<API key> |
<API key>;
sdhci_writel(host, val, SDHCI_CONTROL2);
/*
* FCSEL3[31] FCSEL2[23] FCSEL1[15] FCSEL0[7]
* FCSel[1:0] : Rx Feedback Clock Delay Control
* Inverter delay means10ns delay if SDCLK 50MHz setting
* 01 = Delay1 (basic delay)
* 11 = Delay2 (basic delay + 2ns)
* 00 = Delay3 (inverter delay)
* 10 = Delay4 (inverter delay + 2ns)
*/
val = SDHCI_CTRL3_FCSEL0 | SDHCI_CTRL3_FCSEL1;
sdhci_writel(host, val, SDHCI_CONTROL3);
/*
* SELBASECLK[5:4]
* 00/01 = HCLK
* 10 = EPLL
* 11 = XTI or XEXTCLK
*/
ctrl = sdhci_readl(host, SDHCI_CONTROL2);
ctrl &= ~<API key>(0x3);
ctrl |= <API key>(0x2);
sdhci_writel(host, ctrl, SDHCI_CONTROL2);
}
static void s5p_set_clock(struct sdhci_host *host, u32 div)
{
/* ToDo : Use the Clock Framework */
set_mmc_clk(host->index, div);
}
static const struct sdhci_ops s5p_sdhci_ops = {
.set_clock = &s5p_set_clock,
.set_control_reg = &<API key>,
};
static int s5p_sdhci_core_init(struct sdhci_host *host)
{
host->name = S5P_NAME;
host->quirks = <API key> | <API key> |
<API key> |
<API key> | <API key>;
host->max_clk = 52000000;
host->voltages = MMC_VDD_32_33 | MMC_VDD_33_34 | MMC_VDD_165_195;
host->ops = &s5p_sdhci_ops;
if (host->bus_width == 8)
host->host_caps |= MMC_MODE_8BIT;
#ifndef CONFIG_BLK
return add_sdhci(host, 0, 400000);
#else
return 0;
#endif
}
int s5p_sdhci_init(u32 regbase, int index, int bus_width)
{
struct sdhci_host *host = calloc(1, sizeof(struct sdhci_host));
if (!host) {
printf("sdhci__host allocation fail!\n");
return -ENOMEM;
}
host->ioaddr = (void *)regbase;
host->index = index;
host->bus_width = bus_width;
return s5p_sdhci_core_init(host);
}
#if CONFIG_IS_ENABLED(OF_CONTROL)
struct sdhci_host sdhci_host[SDHCI_MAX_HOSTS];
static int do_sdhci_init(struct sdhci_host *host)
{
int dev_id, flag, ret;
flag = host->bus_width == 8 ? <API key> : PINMUX_FLAG_NONE;
dev_id = host->index + PERIPH_ID_SDMMC0;
ret = <API key>(dev_id, flag);
if (ret) {
printf("external SD not configured\n");
return ret;
}
if (dm_gpio_is_valid(&host->pwr_gpio)) {
dm_gpio_set_value(&host->pwr_gpio, 1);
ret = <API key>(dev_id, flag);
if (ret) {
debug("MMC not configured\n");
return ret;
}
}
if (dm_gpio_is_valid(&host->cd_gpio)) {
ret = dm_gpio_get_value(&host->cd_gpio);
if (ret) {
debug("no SD card detected (%d)\n", ret);
return -ENODEV;
}
}
return s5p_sdhci_core_init(host);
}
static int sdhci_get_config(const void *blob, int node, struct sdhci_host *host)
{
int bus_width, dev_id;
unsigned int base;
/* Get device id */
dev_id = <API key>(blob, node);
if (dev_id < PERIPH_ID_SDMMC0 || dev_id > PERIPH_ID_SDMMC3) {
debug("MMC: Can't get device id\n");
return -EINVAL;
}
host->index = dev_id - PERIPH_ID_SDMMC0;
/* Get bus width */
bus_width = fdtdec_get_int(blob, node, "samsung,bus-width", 0);
if (bus_width <= 0) {
debug("MMC: Can't get bus-width\n");
return -EINVAL;
}
host->bus_width = bus_width;
/* Get the base address from the device node */
base = fdtdec_get_addr(blob, node, "reg");
if (!base) {
debug("MMC: Can't get base address\n");
return -EINVAL;
}
host->ioaddr = (void *)base;
<API key>(offset_to_ofnode(node), "pwr-gpios", 0,
&host->pwr_gpio, GPIOD_IS_OUT);
<API key>(offset_to_ofnode(node), "cd-gpios", 0,
&host->cd_gpio, GPIOD_IS_IN);
return 0;
}
static int process_nodes(const void *blob, int node_list[], int count)
{
struct sdhci_host *host;
int i, node, ret;
int failed = 0;
debug("%s: count = %d\n", __func__, count);
/* build sdhci_host[] for each controller */
for (i = 0; i < count; i++) {
node = node_list[i];
if (node <= 0)
continue;
host = &sdhci_host[i];
ret = sdhci_get_config(blob, node, host);
if (ret) {
printf("%s: failed to decode dev %d (%d)\n", __func__, i, ret);
failed++;
continue;
}
ret = do_sdhci_init(host);
if (ret && ret != -ENODEV) {
printf("%s: failed to initialize dev %d (%d)\n", __func__, i, ret);
failed++;
}
}
/* we only consider it an error when all nodes fail */
return (failed == count ? -1 : 0);
}
int exynos_mmc_init(const void *blob)
{
int count;
int node_list[SDHCI_MAX_HOSTS];
count = <API key>(blob, "mmc",
<API key>, node_list,
SDHCI_MAX_HOSTS);
return process_nodes(blob, node_list, count);
}
#endif
#ifdef CONFIG_DM_MMC
static int s5p_sdhci_probe(struct udevice *dev)
{
struct s5p_sdhci_plat *plat = dev_get_platdata(dev);
struct mmc_uclass_priv *upriv = dev_get_uclass_priv(dev);
struct sdhci_host *host = dev_get_priv(dev);
int ret;
ret = sdhci_get_config(gd->fdt_blob, dev_of_offset(dev), host);
if (ret)
return ret;
ret = do_sdhci_init(host);
if (ret)
return ret;
ret = sdhci_setup_cfg(&plat->cfg, host, 0, 400000);
if (ret)
return ret;
host->mmc = &plat->mmc;
host->mmc->priv = host;
host->mmc->dev = dev;
upriv->mmc = host->mmc;
return sdhci_probe(dev);
}
static int s5p_sdhci_bind(struct udevice *dev)
{
struct s5p_sdhci_plat *plat = dev_get_platdata(dev);
int ret;
ret = sdhci_bind(dev, &plat->mmc, &plat->cfg);
if (ret)
return ret;
return 0;
}
static const struct udevice_id s5p_sdhci_ids[] = {
{ .compatible = "samsung,exynos4412-sdhci"},
{ }
};
U_BOOT_DRIVER(s5p_sdhci_drv) = {
.name = "s5p_sdhci",
.id = UCLASS_MMC,
.of_match = s5p_sdhci_ids,
.bind = s5p_sdhci_bind,
.ops = &sdhci_ops,
.probe = s5p_sdhci_probe,
.<API key> = sizeof(struct sdhci_host),
.<API key> = sizeof(struct s5p_sdhci_plat),
};
#endif /* CONFIG_DM_MMC */
|
package host
import (
"errors"
"io/ioutil"
"path/filepath"
"testing"
"time"
"github.com/NebulousLabs/Sia/crypto"
"github.com/NebulousLabs/Sia/modules"
"github.com/NebulousLabs/Sia/modules/renter"
"github.com/NebulousLabs/Sia/types"
)
const (
testUploadDuration = 20 // Duration in blocks of a standard upload during testing.
// Helper variables to indicate whether renew is being toggled as input to
// uploadFile.
renewEnabled = true
renewDisabled = false
)
// uploadFile uploads a file to the host from the tester's renter. The data
// used to make the file is returned. The nickname of the file in the renter is
// the same as the name provided as input.
func (ht *hostTester) uploadFile(path string, renew bool) ([]byte, error) {
// Check that renting is initialized properly.
err := ht.initRenting()
if err != nil {
return nil, err
}
// Create a file to upload to the host.
source := filepath.Join(ht.persistDir, path+".testfile")
datasize := uint64(1024)
data, err := crypto.RandBytes(int(datasize))
if err != nil {
return nil, err
}
err = ioutil.WriteFile(source, data, 0600)
if err != nil {
return nil, err
}
// Have the renter upload to the host.
rsc, err := renter.NewRSCode(1, 1)
if err != nil {
return nil, err
}
fup := modules.FileUploadParams{
Source: source,
SiaPath: path,
Duration: testUploadDuration,
Renew: renew,
ErasureCode: rsc,
PieceSize: 0,
}
err = ht.renter.Upload(fup)
if err != nil {
return nil, err
}
// Wait until the upload has finished.
for i := 0; i < 100; i++ {
time.Sleep(time.Millisecond * 100)
// Asynchronous processes in the host access obligations by id,
// therefore a lock is required to scan the set of obligations.
if func() bool {
ht.host.mu.Lock()
defer ht.host.mu.Unlock()
for _, ob := range ht.host.obligationsByID {
if ob.fileSize() >= datasize {
return true
}
}
return false
}() {
break
}
}
// Block until the renter is at 50 upload progress - it takes time for the
// contract to confirm renter-side.
complete := false
for i := 0; i < 50 && !complete; i++ {
fileInfos := ht.renter.FileList()
for _, fileInfo := range fileInfos {
if fileInfo.UploadProgress >= 50 {
complete = true
}
}
if complete {
break
}
time.Sleep(time.Millisecond * 50)
}
if !complete {
return nil, errors.New("renter never recognized that the upload completed")
}
// The rest of the upload can be performed under lock.
ht.host.mu.Lock()
defer ht.host.mu.Unlock()
if len(ht.host.obligationsByID) != 1 {
return nil, errors.New("expecting a single obligation")
}
for _, ob := range ht.host.obligationsByID {
if ob.fileSize() >= datasize {
return data, nil
}
}
return nil, errors.New("ht.uploadFile: upload failed")
}
// TestRPCUPload attempts to upload a file to the host, adding coverage to the
// upload function.
func TestRPCUpload(t *testing.T) {
if testing.Short() {
t.SkipNow()
}
ht, err := newHostTester("TestRPCUpload")
if err != nil {
t.Fatal(err)
}
ht.host.mu.RLock()
<API key> := ht.host.anticipatedRevenue
baselineSpace := ht.host.spaceRemaining
ht.host.mu.RUnlock()
_, err = ht.uploadFile("TestRPCUpload - 1", renewDisabled)
if err != nil {
t.Fatal(err)
}
var expectedRevenue types.Currency
func() {
ht.host.mu.RLock()
defer ht.host.mu.RUnlock()
if ht.host.anticipatedRevenue.Cmp(<API key>) <= 0 {
t.Error("Anticipated revenue did not increase after a file was uploaded")
}
if baselineSpace <= ht.host.spaceRemaining {
t.Error("space remaining on the host does not seem to have decreased")
}
expectedRevenue = ht.host.anticipatedRevenue
}()
// Mine until the storage proof goes through, and the obligation gets
// cleared.
for i := types.BlockHeight(0); i <= testUploadDuration+<API key>+defaultWindowSize; i++ {
_, err := ht.miner.AddBlock()
if err != nil {
t.Fatal(err)
}
}
// Check that the storage proof has succeeded.
ht.host.mu.Lock()
defer ht.host.mu.Unlock()
if len(ht.host.obligationsByID) != 0 {
t.Error("host still has obligation, when it should have completed the obligation and submitted a storage proof.")
}
if !ht.host.anticipatedRevenue.IsZero() {
t.Error("host anticipated revenue was not set back to zero")
}
if ht.host.spaceRemaining != baselineSpace {
t.Error("host does not seem to have reclaimed the space after a successful obligation")
}
if expectedRevenue.Cmp(ht.host.revenue) != 0 {
t.Error("host's revenue was not moved from anticipated to expected")
}
}
// TestRPCRenew attempts to upload a file to the host, adding coverage to the
// upload function.
func TestRPCRenew(t *testing.T) {
t.Skip("test skipped because the renter renew function isn't block based")
if testing.Short() {
t.SkipNow()
}
ht, err := newHostTester("TestRPCRenew")
if err != nil {
t.Fatal(err)
}
_, err = ht.uploadFile("TestRPCRenew- 1", renewEnabled)
if err != nil {
t.Fatal(err)
}
ht.host.mu.RLock()
expectedRevenue := ht.host.anticipatedRevenue
<API key> := ht.host.spaceRemaining
ht.host.mu.RUnlock()
// Mine until the storage proof goes through, and the obligation gets
// cleared.
for i := types.BlockHeight(0); i <= testUploadDuration+<API key>+defaultWindowSize; i++ {
_, err := ht.miner.AddBlock()
if err != nil {
t.Fatal(err)
}
}
// Check that the rewards for the first obligation went through, and that
// there is another from the contract being renewed.
ht.host.mu.Lock()
defer ht.host.mu.Unlock()
if len(ht.host.obligationsByID) != 1 {
t.Error("file contract was not renenwed after being completed")
}
if ht.host.anticipatedRevenue.IsZero() {
t.Error("host anticipated revenue should be nonzero")
}
if ht.host.spaceRemaining != <API key> {
t.Error("host space remaining changed after a renew happened")
}
if expectedRevenue.Cmp(ht.host.revenue) > 0 {
t.Error("host's revenue was not increased though a proof was successful")
}
// TODO: Download the file that got renewed, see if the data is correct.
}
// <API key> tests that the host correctly handles missing a storage
// proof.
func <API key>(t *testing.T) {
if testing.Short() {
t.SkipNow()
}
ht, err := newHostTester("<API key>")
if err != nil {
t.Fatal(err)
}
ht.host.mu.RLock()
baselineSpace := ht.host.spaceRemaining
ht.host.mu.RUnlock()
_, err = ht.uploadFile("<API key> - 1", renewDisabled)
if err != nil {
t.Fatal(err)
}
ht.host.mu.RLock()
expectedLostRevenue := ht.host.anticipatedRevenue
ht.host.mu.RUnlock()
// Close the host, then mine enough blocks that the host has missed the
// storage proof window.
err = ht.host.Close()
if err != nil {
t.Fatal(err)
}
for i := types.BlockHeight(0); i <= testUploadDuration+defaultWindowSize+2; i++ {
_, err := ht.miner.AddBlock()
if err != nil {
t.Fatal(err)
}
}
// Restart the host. While catching up, the host should realize that it
// missed a storage proof, and should delete the obligation.
rebootHost, err := New(ht.cs, ht.tpool, ht.wallet, ":0", filepath.Join(ht.persistDir, modules.HostDir))
if err != nil {
t.Fatal(err)
}
// Host should delete the obligation before finishing startup.
rebootHost.mu.Lock()
defer rebootHost.mu.Unlock()
if len(rebootHost.obligationsByID) != 0 {
t.Error("host did not delete a dead storage proof at startup")
}
if !rebootHost.anticipatedRevenue.IsZero() {
t.Error("host did not subtract out anticipated revenue")
}
if rebootHost.spaceRemaining != baselineSpace {
t.Error("host did not reallocate space after failed storage proof")
}
if rebootHost.lostRevenue.Cmp(expectedLostRevenue) != 0 {
t.Error("host did not correctly report lost revenue")
}
}
// <API key> tests that a host who went offline for a few
// blocks is still able to successfully submit a storage proof.
func <API key>(t *testing.T) {
if testing.Short() {
t.SkipNow()
}
ht, err := newHostTester("<API key>")
if err != nil {
t.Fatal(err)
}
ht.host.mu.RLock()
baselineSpace := ht.host.spaceRemaining
ht.host.mu.RUnlock()
_, err = ht.uploadFile("<API key> - 1", renewDisabled)
if err != nil {
t.Fatal(err)
}
ht.host.mu.RLock()
expectedRevenue := ht.host.anticipatedRevenue
ht.host.mu.RUnlock()
// Close the host, then mine some blocks, but not enough that the host
// misses the storage proof.
err = ht.host.Close()
if err != nil {
t.Fatal(err)
}
for i := 0; i <= 5; i++ {
_, err := ht.miner.AddBlock()
if err != nil {
t.Fatal(err)
}
}
// Restart the host, and mine enough blocks that the host can submit a
// successful storage proof.
rebootHost, err := New(ht.cs, ht.tpool, ht.wallet, ":0", filepath.Join(ht.persistDir, modules.HostDir))
if err != nil {
t.Fatal(err)
}
if rebootHost.blockHeight != ht.cs.Height() {
t.Error("Host block height does not match the cs block height")
}
for i := types.BlockHeight(0); i <= testUploadDuration+defaultWindowSize+<API key>; i++ {
_, err := ht.miner.AddBlock()
if err != nil {
t.Fatal(err)
}
}
// Confirm that the storage proof was successful.
rebootHost.mu.Lock()
defer rebootHost.mu.Unlock()
if len(rebootHost.obligationsByID) != 0 {
t.Error("host did not delete a finished obligation")
}
if !rebootHost.anticipatedRevenue.IsZero() {
t.Error("host did not subtract out anticipated revenue")
}
if rebootHost.spaceRemaining != baselineSpace {
t.Error("host did not reallocate space after storage proof")
}
if rebootHost.revenue.Cmp(expectedRevenue) != 0 {
t.Error("host did not correctly report revenue gains")
}
}
// <API key> tests that a host who went offline for a
// few blocks, corrupted the consensus database, but is still able to correctly
// create a storage proof.
func <API key>(t *testing.T) {
if testing.Short() {
t.SkipNow()
}
ht, err := newHostTester("<API key>")
if err != nil {
t.Fatal(err)
}
ht.host.mu.RLock()
baselineSpace := ht.host.spaceRemaining
ht.host.mu.RUnlock()
_, err = ht.uploadFile("<API key> - 1", renewDisabled)
if err != nil {
t.Fatal(err)
}
ht.host.mu.RLock()
expectedRevenue := ht.host.anticipatedRevenue
ht.host.mu.RUnlock()
// Corrupt the host's consensus tracking, close the host, then mine some
// blocks, but not enough that the host misses the storage proof. The host
// will need to perform a rescan and update its obligations correctly.
ht.host.mu.Lock()
ht.host.recentChange[0]++
ht.host.mu.Unlock()
err = ht.host.Close()
if err != nil {
t.Fatal(err)
}
for i := 0; i <= 3; i++ {
_, err := ht.miner.AddBlock()
if err != nil {
t.Fatal(err)
}
}
// Restart the host, and mine enough blocks that the host can submit a
// successful storage proof.
rebootHost, err := New(ht.cs, ht.tpool, ht.wallet, ":0", filepath.Join(ht.persistDir, modules.HostDir))
if err != nil {
t.Fatal(err)
}
if rebootHost.blockHeight != ht.cs.Height() {
t.Error("Host block height does not match the cs block height")
}
if len(rebootHost.obligationsByID) == 0 {
t.Error("host did not correctly reload its obligation")
}
for i := types.BlockHeight(0); i <= testUploadDuration+defaultWindowSize+<API key>; i++ {
_, err := ht.miner.AddBlock()
if err != nil {
t.Fatal(err)
}
}
// Confirm that the storage proof was successful.
rebootHost.mu.Lock()
defer rebootHost.mu.Unlock()
if len(rebootHost.obligationsByID) != 0 {
t.Error("host did not delete a finished obligation")
}
if !rebootHost.anticipatedRevenue.IsZero() {
t.Error("host did not subtract out anticipated revenue")
}
if rebootHost.spaceRemaining != baselineSpace {
t.Error("host did not reallocate space after storage proof")
}
if rebootHost.revenue.Cmp(expectedRevenue) != 0 {
t.Error("host did not correctly report revenue gains")
}
if rebootHost.lostRevenue.Cmp(expectedRevenue) == 0 {
t.Error("host is reporting losses on the file contract")
}
}
|
import { async, ComponentFixture, TestBed } from '@angular/core/testing';
import { Comp624Component } from './comp-624.component';
describe('Comp624Component', () => {
let component: Comp624Component;
let fixture: ComponentFixture<Comp624Component>;
beforeEach(async(() => {
TestBed.<API key>({
declarations: [ Comp624Component ]
})
.compileComponents();
}));
beforeEach(() => {
fixture = TestBed.createComponent(Comp624Component);
component = fixture.componentInstance;
fixture.detectChanges();
});
it('should create', () => {
expect(component).toBeTruthy();
});
});
|
#include "glprogram.h"
#include <gl/gl3w.h>
#include <cstdio>
bool compileStatus(GLuint shader) {
int ret;
glGetShaderiv(shader, GL_COMPILE_STATUS, &ret);
return ret;
}
bool linkStatus(GLuint program) {
int ret;
glGetProgramiv(program, GL_LINK_STATUS, &ret);
return ret;
}
bool compileShader(GLuint handle, GLenum stype, const char* src) {
int shader_len = strlen(src);
glShaderSource(handle, 1, &src, &shader_len);
glCompileShader(handle);
if (!compileStatus(handle)) {
char buff[2048];
int nwritten;
glGetShaderInfoLog(handle, 2048, &nwritten, buff);
const char* typelabel = stype == GL_VERTEX_SHADER ? "vertex" : (stype == GL_FRAGMENT_SHADER ? "fragment" : "unknown");
printf("Error in %s shader\n%s\n", typelabel, buff);
return false;
}
return true;
}
int compileShader(GLenum type, const char* src) {
GLuint handle = glCreateShader(type);
compileShader(handle, type, src);
return handle;
}
bool linkProgram(GLuint handle, GLuint vshader, GLuint fshader) {
glAttachShader(handle, vshader);
glAttachShader(handle, fshader);
glLinkProgram(handle);
if (!linkStatus(handle)) {
char buff[2048];
int nwritten;
glGetProgramInfoLog(handle, 2048, &nwritten, buff);
printf("Program link error:\n%s\n", buff);
return false;
}
return true;
}
int linkProgram(const char* vshader_src, const char* fshader_src) {
GLuint program = glCreateProgram();
GLuint vshader = compileShader(GL_VERTEX_SHADER, vshader_src);
GLuint fshader = compileShader(GL_FRAGMENT_SHADER, fshader_src);
if (!linkProgram(program, vshader, fshader)) {
glDeleteProgram(program);
program = 0;
}
glDeleteShader(vshader);
glDeleteShader(fshader);
return program;
}
|
#include <climits>
#include <cstdlib>
#include <cstring>
#include "orderline.h"
#include "../src/schema/conversion.h"
using namespace std;
void OrderlineStore::add(string elements[10]) {
add_instance(atoi(elements[0].c_str()),
atoi(elements[1].c_str()),
atoi(elements[2].c_str()),
atoi(elements[3].c_str()),
atoi(elements[4].c_str()),
atoi(elements[5].c_str()),
db_stod(elements[6]),
db_stol(elements[7]),
db_stol(elements[8]),
elements[9]);
}
void OrderlineStore::add_instance(int32_t ol_o_id, int32_t ol_d_id, int32_t ol_w_id, int32_t ol_number, int32_t ol_i_id, int32_t ol_supply_w_id, uint64_t ol_delivery_d, int64_t ol_quantity, int64_t ol_amount, std::string ol_dist_info) {
this->ol_o_id.push_back(ol_o_id);
this->ol_d_id.push_back(ol_d_id);
this->ol_w_id.push_back(ol_w_id);
this->ol_number.push_back(ol_number);
this->ol_i_id.push_back(ol_i_id);
this->ol_supply_w_id.push_back(ol_supply_w_id);
this->ol_delivery_d.push_back(ol_delivery_d);
this->ol_quantity.push_back(ol_quantity);
this->ol_amount.push_back(ol_amount);
this->ol_dist_info.push_back(ol_dist_info);
pkIndex[std::make_tuple(this->ol_w_id[tid], this->ol_d_id[tid], this->ol_o_id[tid], this->ol_number[tid])] = tid;
tid++;
}
void OrderlineStore::remove(uint64_t tid) {
auto pkKey = std::make_tuple(this->ol_w_id[tid], this->ol_d_id[tid], this->ol_o_id[tid], this->ol_number[tid]);
auto pkIt = pkIndex.find(pkKey);
pkIndex.erase(pkIt);
// We want to move the last item to the deleted item's position
// We have one item less now, so decrease TID for next add_instance
uint64_t tidToSwap = --this->tid;
if (tid != tidToSwap) {
// Move data from last item to deleted item's position
this->ol_o_id[tid] = this->ol_o_id[tidToSwap];
this->ol_d_id[tid] = this->ol_d_id[tidToSwap];
this->ol_w_id[tid] = this->ol_w_id[tidToSwap];
this->ol_number[tid] = this->ol_number[tidToSwap];
this->ol_i_id[tid] = this->ol_i_id[tidToSwap];
this->ol_supply_w_id[tid] = this->ol_supply_w_id[tidToSwap];
this->ol_delivery_d[tid] = this->ol_delivery_d[tidToSwap];
this->ol_quantity[tid] = this->ol_quantity[tidToSwap];
this->ol_amount[tid] = this->ol_amount[tidToSwap];
this->ol_dist_info.set(tid, this->ol_dist_info[tidToSwap]);
// Set swapped item's TID in index
pkIndex[std::make_tuple(this->ol_w_id[tid], this->ol_d_id[tid], this->ol_o_id[tid], this->ol_number[tid])] = tid;
}
// Delete the data
this->ol_o_id.pop_back();
this->ol_d_id.pop_back();
this->ol_w_id.pop_back();
this->ol_number.pop_back();
this->ol_i_id.pop_back();
this->ol_supply_w_id.pop_back();
this->ol_delivery_d.pop_back();
this->ol_quantity.pop_back();
this->ol_amount.pop_back();
this->ol_dist_info.pop_back();
}
uint64_t OrderlineStore::get(int32_t ol_w_id, int32_t ol_d_id, int32_t ol_o_id, int32_t ol_number) {
return pkIndex[std::make_tuple(ol_w_id, ol_d_id, ol_o_id, ol_number)];
}
std::pair<OrderlineStore::pkIndexType::iterator, OrderlineStore::pkIndexType::iterator> OrderlineStore::get(int32_t ol_w_id, int32_t ol_d_id, int32_t ol_o_id) {
return std::make_pair(
pkIndex.lower_bound(std::make_tuple(ol_w_id, ol_d_id, ol_o_id, 0)),
pkIndex.upper_bound(std::make_tuple(ol_w_id, ol_d_id, ol_o_id, INT_MAX)));
}
|
using Microsoft.Owin.Security.OAuth;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Http;
namespace CodeReaction.Web
{
public static class WebApiConfig
{
public static void Register(HttpConfiguration config)
{
// Configure Web API to use only bearer token authentication.
config.<API key>();
config.Filters.Add(new Host<API key>(OAuthDefaults.AuthenticationType));
// Web API routes
config.<API key>();
config.EnableCors();
}
}
}
|
require 'spec_helper'
describe Emarsys::Broadcast::Email do
it 'should validate valid email' do
expect(Emarsys::Broadcast::Email::validate 'winston.smith-1984@big.brother.ru').to be_truthy
expect(Emarsys::Broadcast::Email::validate 'abc@example.com').to be_truthy
end
it 'should not validate invalid email' do
expect(Emarsys::Broadcast::Email::validate 'some invalid@email').to be_falsey
end
end
|
<html>
<head>
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>That's Life</title>
<style>
body { margin: 0;
background-color: #f0f0f0;
}
canvas { width: 100%; height: 100% }
#ex1Slider .slider-selection {
background: #009900;
}
#ex1Slider {
margin-left: 10px;
margin-right: 10px;
}
.modal-header, h4, .close {
background-color: #5cb85c;
color:white !important;
text-align: center;
font-size: 30px;
}
.modal-footer {
background-color: #f9f9f9;
}
#myModal {
margin-top: 75px;
}
div.game {
overflow: hidden;
}
#control-panel {
padding-top: 20px;
padding-bottom: 5px;
background-color: #bbbbbb;
}
#animate-button.active {
background-color: #009900
}
body {
}
body, html { height: 100%; }
</style>
<!-- Latest compiled and minified CSS -->
<link rel="stylesheet" href="css/bootstrap.min.css">
<!-- Optional theme -->
<link rel="stylesheet" href="css/bootstrap-theme.min.css">
<link rel="stylesheet" href="css/bootstrap-slider.css">
</head>
<body>
<script src="js/jquery.min.js"></script>
<script src="js/bootstrap.min.js"></script>
<script src="js/bootstrap-slider.min.js"></script>
<div class="game">
<div id="control-panel">
<p class="text-center">
<button id="step-button" type="button" title="Step one generation" class="btn btn-default" aria-label="Left Align">
<span class="glyphicon <API key>" aria-hidden="true"></span>
</button>
<button id="play-button" type="button" title="Play/Pause" class="btn btn-default" aria-label="Left Align">
<span id="play-button-glyph" class="glyphicon glyphicon-play" aria-hidden="true"></span>
</button>
<button id="animate-button" type="button" title="Toggle rendering while playing" class="btn btn-default active" aria-label="Left Align">
<span id="<API key>" class="glyphicon <API key>" aria-hidden="true"></span>
</button>
<button id="clear-button" type="button" title="Clear board" class="btn btn-default" aria-label="Left Align">
<span class="glyphicon glyphicon-trash" aria-hidden="true"></span>
</button>
<button id="reset-button" data-toggle="button" type="button" title="Reset board to default configuration" class="btn btn-default" aria-label="Left Align">
<span class="glyphicon glyphicon-repeat" aria-hidden="true"></span>
</button>
<!
<button type="button" class="btn btn-default" title="Compress Memory" aria-label="Left Align" onclick="compressBoard()">
<span id="compress-button" class="glyphicon <API key>" aria-hidden="true"></span>
</button>
<span id="render-kind" class="btn-group btn-group-sm" role="group" aria-label="...">
<button title="Choose WebGL renderer - faster, but less stable" id="render-kind-webgl" type="button" class="btn btn-default">WebGL</button>
<button title="Choose Canvas renderer - slower, but more stable" id="render-kind-canvas" type="button" class="btn btn-default active">Canvas</button>
</span>
<span title="Play Speed">
<input id="ex1" data-slider-id='ex1Slider' type="text" data-slider-min="-1000" data-slider-max="0" data-slider-step="50" data-slider-value="0"/>
</span>
<button id="help-button" type="button" title="Help" class="btn btn-default" aria-label="Left Align">
<span class="glyphicon <API key>" aria-hidden="true"></span>
</button>
<button id="test-button" type="button" title="Test" class="btn btn-default" aria-label="Left Align">
<span class="glyphicon glyphicon-ok" aria-hidden="true"></span>
</button>
</p>
<p id='status-field' class="text-center">Status</p>
<p class="text-center"><small><a href="https://github.com/esscbee/thats-life" target="github">That's Life!</a></small></p>
</div>
<input style="display:none;" id="fileDialog" type="file" accept=".life,text/plain;charset=utf-8"/>
<script src="js/three.min.js"></script>
<script src="js/CanvasRenderer.js"></script>
<script src="js/Projector.js"></script>
<script src="js/OrbitControls.js"></script>
<script src="LIFE.js"></script>
<script src="ThreeDBoard.js"></script>
<script src="BoardModel.js"></script>
<script src="js/test-results.js"></script>
<script>
var BOARD_SIZE_Y = 200;
var BOARD_SIZE_X = 200;
var board;
var boardModel;
var render = function() {
if(board && boardModel)
board.render();
// console.log('render!');
}
var speedSlider = $('#ex1');
speedSlider.slider({
formatter: function(value) {
if(boardModel) {
boardModel.setSpeed(-value);
}
}
});
function isWebGL() {
var webGL = true;
var active = $("#render-kind .active");
if(active.length > 0) {
webGL = active[0].id == 'render-kind-webgl';
}
return webGL;
}
function isAnimate() {
var v = $("#animate-button");
var ret = true;
if(v)
ret = v.hasClass("active");
return ret;
}
function updateAnimate(doAnimate) {
var anim_button = $("#animate-button");
if(doAnimate == undefined)
doAnimate = isAnimate();
else {
if(doAnimate) {
anim_button.addClass("active");
} else {
anim_button.removeClass("active");
}
}
}
function createBoard() {
var height = $("#control-panel").outerHeight() + 10 ;
return new LIFE.ThreeDBoard(BOARD_SIZE_X, BOARD_SIZE_Y, window, document, isWebGL(), height);
}
function resetBoardModel(reinit) {
setPlayButtonState(false);
if(board) {
var d = board;
board = undefined;
d.dispose();
}
if(boardModel) {
var d = boardModel;
boardModel = undefined;
d.dispose();
}
if(reinit) {
board = createBoard();
boardModel = new LIFE.BoardModel(BOARD_SIZE_X, BOARD_SIZE_Y, board, updateStatus);
boardModel.setSpeed(-speedSlider.slider('getValue'));
boardModel.updateStatus();
board.ready();
boardModel.animate(true);
play(true);
}
}
function changeRenderer() {
if(board) {
var d = board;
board = undefined;
d.dispose();
}
board = createBoard();
boardModel.setBoard(board);
updateAnimate();
boardModel.updateStatus();
board.ready();
}
function populateBoardModel() {
var dj = Math.floor(BOARD_SIZE_X * 1.5);
populateBoardModelN(dj);
}
function populateBoardModelN(dj) {
var startJ = Math.floor((BOARD_SIZE_X - dj) / 2);
var theI = Math.floor(BOARD_SIZE_Y / 2);
for(var j = startJ; j < (startJ + dj); j++) {
boardModel.setCell(j, theI, 1, false);
}
boardModel.updateStatus();
}
function <API key>() {
resetBoardModel(true);
populateBoardModel(true);
}
function processKeyEvent(event, turnOn) {
if(board) {
board.processKeyEvent(event, turnOn);
}
}
$(window).keydown(function(event){
processKeyEvent(event, true);
});
$(window).keyup(function(event){
processKeyEvent(event, false);
});
// window.onresize = function(event) {
// //camera.aspect = window.innerWidth / window.innerHeight;
// //camera.<API key>();
// renderer.setSize( window.innerWidth, window.innerHeight );
// console.log('resize: ' + window.innerWidth + ', ' + window.innerHeight);
function displayHelp() {
alert('help');
}
function updateStatus(contents, growth, turnOn) {
if(growth == undefined) {
// here have setting to toggle - bit of a hack
if(contents == 'play') {
setPlayButtonState(turnOn);
return;
}
}
var color = 'black';
if(growth > 0)
color = 'green';
else if(growth < 0)
color = 'red';
if(contents == undefined)
contents = '';
var status = document.getElementById('status-field');
status.innerHTML = contents;
status.style.color = color;
}
function setPlayButtonState(isPlay) {
var playButton = document.getElementById("play-button-glyph");
if(!isPlay) {
playButton.className = 'glyphicon glyphicon-play';
} else {
playButton.className = 'glyphicon glyphicon-pause';
}
}
function play(state, stopGen) {
if(!board || !boardModel)
return;
var newState = !boardModel.playing;
if(state != undefined)
newState = state;
boardModel.play(window, newState, stopGen);
setPlayButtonState(newState);
var doAnimate = !newState || isAnimate();
boardModel.animate(doAnimate);
}
function doStep() {
if(!board || !boardModel)
return;
if(boardModel.playing) {
play(false);
return;
}
boardModel.generate(true);
}
// function editNavToggle(setting) {
// if(!board)
// return;
// var navEditButton = document.getElementById("edit-nav-button");
// if(!board.navEditToggle(setting)) {
// navEditButton.className = 'glyphicon <API key>';
// } else {
// navEditButton.className = 'glyphicon glyphicon-pencil';
function compressBoard() {
if(!boardModel) {
boardModel.compressBoard();
}
}
$(document).ready(function() {
<API key>();
if(board) {
board.ready();
}
$("#help-button").click(function() {
$("#myModal").modal();
$("#myModal").on('hidden.bs.modal', function () {
});
});
$("#reset-button").click(function() {
<API key>(true);
});
$("#step-button").click(function() {
doStep();
});
$("#play-button").click(function() {
play();
});
$("#clear-button").click(function() {
resetBoardModel(true);
});
$("#render-kind .btn").click(function(event) {
console.log(event.currentTarget.id);
$("#render-kind .btn").removeClass('active');
$(event.currentTarget).addClass('active');
changeRenderer();
});
$("#animate-button").click(function(event) {
if(!This)
return;
var a = !isAnimate();
updateAnimate(a);
if(boardModel.playing)
boardModel.animate(a);
else
boardModel.animate(true);
});
$("#test-button").click(function(event) {
initializeTests();
resetBoardModel(true);
populateBoardModelN(200);
updateAnimate(true);
var processedOuter = false;
play(true, function(gen) {
var testNum = 0;
var results;
var errors = "";
if(gen <= 10 || processedOuter)
return;
processedOuter = true;
// play(false);
results = boardModel.getState();
var theseErrors = checkResults(testNum, results);
if(theseErrors && theseErrors.length) {
errors = 'Test: ' + testNum + ' failed:\n' + theseErrors;
}
results = board.getState();
theseErrors = checkResults(++testNum, results);
if(theseErrors && theseErrors.length) {
if(errors.length)
errors += '\n';
errors = 'Test: ' + testNum + ' failed:\n' + theseErrors;
}
updateAnimate(false);
play(true, function(gen) {
if(gen <= 100)
return;
play(false);
updateAnimate(true);
results = boardModel.getState();
var theseErrors = checkResults(++testNum, results);
if(theseErrors && theseErrors.length) {
errors = 'Test: ' + testNum + ' failed:\n' + theseErrors;
}
results = board.getState();
theseErrors = checkResults(++testNum, results);
if(theseErrors && theseErrors.length) {
if(errors.length)
errors += '\n';
errors = 'Test: ' + testNum + ' failed:\n' + theseErrors;
}
updateAnimate(true);
if(errors.length) {
console.log(errors);
}
});
});
});
});
</script>
</div>
<div class="container">
<!-- Modal -->
<div class="modal fade" id="myModal" role="dialog">
<div class="modal-dialog">
<!-- Modal content-->
<div class="modal-content">
<div class="modal-header" style="padding:35px 50px;">
<button type="button" class="close" data-dismiss="modal">×</button>
<h4><span class="glyphicon glyphicon-hdd"></span> That's Life!</h4>
</div>
<div class="modal-body" style="padding:40px 50px;">
<p>This is a javascript / WebGL (on
<a target="mrdoob" href="https://github.com/mrdoob/three.js">three.js</a>
) /
<a target="bootstrap" href="http://getbootstrap.com/">bootstrap</a>
implementation of
<a target="conway" href="https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life">Conway's Game of Life</a>.</p>
<p>Key Controls: </p>
<ul>
<li>Hold down [Space] - Slide Board, mouse to move camera, mouse wheel to zoom</li>
<li>Hold down [Control] - Turn mouse into erase cursor</li>
<li>Otherwise use the mouse to draw living cells</li>
</ul>
<p><a target="_github" href="https:
</div>
<div class="modal-footer">
<button type="button" class="btn btn-success btn-default pull-left" data-dismiss="modal"><span class="glyphicon glyphicon-ok-sign"></span> Ok</button>
</div>
</div>
</div>
</div>
</div>
</body>
</html>
|
var dp = jQuery;
dp.noConflict();
dp(document).ready(function() {
//SMOOTH SCROLL
dp('a[href^="#"]').bind('click.smoothscroll', function(e) {
e.preventDefault();
dp('html,body').animate({
scrollTop: dp(this.hash).offset().top
}, 1200);
});
//SUPER SLIDES
// dp('#home-slide').superslides({
// animation: 'fade', // You can choose either fade or slide
// play: 6000
//ANIMAZE
dp('.animaze').bind('inview', function(event, visible) {
if (visible) {
dp(this).stop().animate({
opacity: 1,
top: '0px'
}, 500);
}
/* REMOVE THIS if you want to repeat the animation after the element not in view
else {
$(this).stop().animate({ opacity: 0 });
$(this).removeAttr('style');
}*/
});
dp('.animaze').stop().animate({
opacity: 0
});
//SERVICES
dp("#dp-service").sudoSlider({
customLink: 'a.servicesLink',
responsive: true,
speed: 350,
prevNext: false,
useCSS: true,
effect: "fadeOutIn",
continuous: true,
updateBefore: true
});
//TEXT ROTATOR
dp(".rotatez").textrotator({
animation: "fade",
separator: ",",
speed: 1700
});
//PORTFOLIO
dp('.portfolioContainer').mixitup({
filterSelector: '.portfolioFilter a',
targetSelector: '.portfolio-item',
effects: ['fade', 'scale']
});
//QUOTE SLIDE
dp("#quote-slider").sudoSlider({
customLink: 'a.quoteLink',
speed: 425,
prevNext: true,
responsive: true,
prevHtml: '<a href="#" class="<API key>"><i class="icon-arrow-left"></i></a>',
nextHtml: '<a href="#" class="<API key>"><i class="icon-arrow-right"></i></a>',
useCSS: true,
continuous: true,
effect: "fadeOutIn",
updateBefore: true
});
//MAGNIFIC POPUP
dp('.popup').magnificPopup({
type: 'image'
});
//PARALLAX
dp('.parallaxize').parallax("50%", 0.3);
// CONTACT SLIDER
dp("#contact-slider").sudoSlider({
customLink: 'a.contactLink',
speed: 750,
responsive: true,
prevNext: false,
useCSS: false,
continuous: false,
updateBefore: true,
effect: "fadeOutIn"
});
//Map
dp('#map').gmap3({
map: {
options: {
maxZoom: 15
}
},
marker: {
address: "Haltern am See, Weseler Str. 151", // PUT YOUR ADDRESS HERE
options: {
icon: new google.maps.MarkerImage(
"http://cdn.webiconset.com/map-icons/images/pin6.png",
new google.maps.Size(42, 69, "px", "px")
)
}
}
},
"autofit");
});
dp(window).load(function() {
dp("#lazyload").fadeOut();
});
|
<table width="90%" border="0"><tr><td><script>function openfile(url) {fullwin = window.open(url, "fulltext", "toolbar=no,location=no,directories=no,status=no,menubar=no,scrollbars=yes,resizable=yes");}</script><div class="layoutclass_pic"><div class="<API key>"><table class="ztable"><tr><th class="ztd1"><b> </b></th><td class="ztd2"></td></tr>
<tr><th class="ztd1"><b> </b></th><td class="ztd2"> <font class="english_word">∼</font><font class="english_word"></font><font class="english_word"></font></font></td></tr>
</td></tr></table></div> <!-- <API key> --><div class="<API key>"></div> <!-- <API key> --></div> <!-- layoutclass_pic --></td></tr></table>
|
<?php
require "header.php";
require "menu.php";
session_start();
require "config.php";
require_once __DIR__ . '/src/Facebook/autoload.php';
$fb = new Facebook\Facebook([
'app_id' => APP_ID,
'app_secret' => APP_SECRET,
'<API key>' => APP_VERSION
]);
$helper = $fb-><API key>();
$permissions = ['email']; // optional
try {
if (isset($_SESSION['<API key>'])) {
$accessToken = $_SESSION['<API key>'];
} else {
$accessToken = $helper->getAccessToken();
}
} catch(Facebook\Exceptions\<API key> $e) {
// When Graph returns an error
echo 'Graph returned an error: ' . $e->getMessage();
exit;
} catch(Facebook\Exceptions\<API key> $e) {
// When validation fails or other local issues
echo 'Facebook SDK returned an error: ' . $e->getMessage();
exit;
}
if (isset($accessToken)) {
if (isset($_SESSION['<API key>'])) {
$fb-><API key>($_SESSION['<API key>']);
} else {
// getting short-lived access token
$_SESSION['<API key>'] = (string) $accessToken;
// OAuth 2.0 client handler
$oAuth2Client = $fb->getOAuth2Client();
// Exchanges a short-lived access token for a long-lived one
$<API key> = $oAuth2Client-><API key>($_SESSION['<API key>']);
$_SESSION['<API key>'] = (string) $<API key>;
// setting default access token to be used in script
$fb-><API key>($_SESSION['<API key>']);
}
// redirect the user back to the same page if it has "code" GET variable
if (isset($_GET['code'])) {
header('Location: ./');
}
// getting basic info about user
try {
$profile_request = $fb->get('/me?fields=name,first_name,last_name,email');
$profile = $profile_request->getGraphNode()->asArray();
} catch(Facebook\Exceptions\<API key> $e) {
// When Graph returns an error
echo 'Graph returned an error: ' . $e->getMessage();
session_destroy();
// redirecting user back to app login page
header("Location: ./");
exit;
} catch(Facebook\Exceptions\<API key> $e) {
// When validation fails or other local issues
echo 'Facebook SDK returned an error: ' . $e->getMessage();
exit;
}
// printing $profile array on the screen which holds the basic info about user
print_r($profile);
// Now you can redirect to another page and use the access token from $_SESSION['<API key>']
} else {
// replace your website URL same as added in the developers.facebook.com/apps e.g. if you used http instead of https and you used non-www version or www version of your website then you must add the same here
$loginUrl = $helper->getLoginUrl('https:
echo '<a href="' . $loginUrl . '">Log in with Facebook!</a>';
}
include "footer.php";
|
<?php
namespace Propel\Tests\Generator\Migration;
/**
* @group database
*/
class ForeignKeyTest extends MigrationTestCase
{
public function testAdd()
{
$originXml = '
<database>
<entity name="migration_test_6">
<field name="id" type="integer" primaryKey="true" autoIncrement="true" />
<field name="title" required="true" />
</entity>
<entity name="migration_test_7">
<field name="id" type="integer" primaryKey="true" autoIncrement="true" />
<field name="title" required="true" />
<field name="test_6_id" />
</entity>
</database>
';
$targetXml = '
<database>
<entity name="migration_test_6">
<field name="id" type="integer" primaryKey="true" autoIncrement="true" />
<field name="title" required="true" />
</entity>
<entity name="migration_test_7">
<field name="id" type="integer" primaryKey="true" autoIncrement="true" />
<field name="title" required="true" />
<field name="test_6_id" type="integer" />
<foreign-key foreignTable="migration_test_6" onDelete="cascade" onUpdate="cascade">
<reference local="test_6_id" foreign="id" />
</foreign-key>
</entity>
</database>
';
$this->migrateAndTest($originXml, $targetXml);
}
public function testAddNotUnique()
{
$originXml = '
<database>
<entity name="migration_test_6_1">
<field name="id" type="integer" primaryKey="true" autoIncrement="true" />
<field name="title" required="true" />
</entity>
</database>
';
$targetXml = '
<database>
<entity name="migration_test_6_1">
<field name="id" type="integer" primaryKey="true" autoIncrement="true" />
<field name="id2" type="integer"/>
<field name="title" required="true" />
</entity>
<entity name="migration_test_7_1">
<field name="id" type="integer" primaryKey="true" autoIncrement="true" />
<field name="title" required="true" />
<field name="test_6_id" type="integer" />
<foreign-key foreignTable="migration_test_6_1" onDelete="cascade" onUpdate="cascade">
<reference local="test_6_id" foreign="id2" />
</foreign-key>
</entity>
</database>
';
$this->migrateAndTest($originXml, $targetXml);
}
public function testRemove()
{
$originXml = '
<database>
<entity name="migration_test_6">
<field name="id" type="integer" primaryKey="true" autoIncrement="true" />
<field name="title" required="true" />
</entity>
<entity name="migration_test_7">
<field name="id" type="integer" primaryKey="true" autoIncrement="true" />
<field name="title" required="true" />
<field name="test_6_id" type="integer" />
<foreign-key foreignTable="migration_test_6" onDelete="cascade" onUpdate="cascade">
<reference local="test_6_id" foreign="id" />
</foreign-key>
</entity>
</database>
';
$targetXml = '
<database>
<entity name="migration_test_6">
<field name="id" type="integer" primaryKey="true" autoIncrement="true" />
<field name="title" required="true" />
</entity>
<entity name="migration_test_7">
<field name="id" type="integer" primaryKey="true" autoIncrement="true" />
<field name="title" required="true" />
<field name="test_6_id" />
</entity>
</database>
';
$this->migrateAndTest($originXml, $targetXml);
}
public function testChange()
{
$originXml = '
<database>
<entity name="migration_test_6">
<field name="id" type="integer" primaryKey="true" autoIncrement="true" />
<field name="id2" type="integer" primaryKey="true"/>
<field name="title" required="true" />
</entity>
<entity name="migration_test_7">
<field name="id" type="integer" primaryKey="true" autoIncrement="true" />
<field name="title" required="true" />
<field name="test_6_id" type="integer" />
<field name="test_6_id2" type="integer" />
<foreign-key foreignTable="migration_test_6" onDelete="cascade" onUpdate="cascade">
<reference local="test_6_id" foreign="id" />
<reference local="test_6_id2" foreign="id2" />
</foreign-key>
</entity>
</database>
';
$targetXml = '
<database>
<entity name="migration_test_6">
<field name="id" type="integer" primaryKey="true" autoIncrement="true" />
<field name="id2" type="integer" primaryKey="true"/>
<field name="title" required="true" />
</entity>
<entity name="migration_test_7">
<field name="id" type="integer" primaryKey="true" autoIncrement="true" />
<field name="title" required="true" />
<field name="test_6_id" />
<field name="test_6_id2" />
</entity>
</database>
';
$this->migrateAndTest($originXml, $targetXml);
}
}
|
<?php
namespace Theintz\PhpDaemon\Plugin;
use Theintz\PhpDaemon\Daemon;
use Theintz\PhpDaemon\Exception;
use Theintz\PhpDaemon\IPlugin;
use Theintz\PhpDaemon\Lib\Command;
/**
* Create a simple socket server.
* Supply an IP and Port for incoming connections. Add any number of Command objects to parse client input.
*
* Used in blocking mode, this can be the backbone of a Daemon based server with a loop_interval set to Null.
* Alternatively, you could set $blocking = false and use it to interact with a timer-based Daemon application.
*
* Can be combined with the Worker API by adding Command objects that call methods attached to a Worker. That would leave
* the main Application process to handle connections and client input, worker process management, and passing commands
* between client input to worker calls, and worker return values to client output.
*
*/
class Server implements IPlugin
{
const COMMAND_CONNECT = 'CLIENT_CONNECT';
const COMMAND_DISCONNECT = 'CLIENT_DISCONNECT';
const COMMAND_DESTRUCT = 'SERVER_DISCONNECT';
/**
* @var Daemon
*/
public $daemon;
/**
* The IP Address server will listen on
* @var string IP
*/
public $ip;
/**
* The Port the server will listen on
* @var integer
*/
public $port;
/**
* The socket resource
* @var Resource
*/
public $socket;
/**
* Maximum number of concurrent clients
* @var int
*/
public $max_clients = 10;
/**
* Maximum bytes read from a given client connection at a time
* @var int
*/
public $max_read = 1024;
/**
* Array of stdClass client structs.
* @var stdClass[]
*/
public $clients = array();
/**
* Is this a Blocking server or a Polling server? When in blocking mode, the server will
* wait for connections & commands indefinitely. When polling, it will look for any connections or commands awaiting
* a response and return immediately if there aren't any.
* @var bool
*/
public $blocking = false;
/**
* Write verbose logging to the application log when true.
* @var bool
*/
public $debug = true;
/**
* Array of Command objects to match input against.
* Note: In addition to input rec'd from the client, the server will emit the following commands when appropriate:
* CLIENT_CONNECT(stdClass Client)
* CLIENT_DISCONNECT(stdClass Client)
* SERVER_DISCONNECT
*
* @var Command[]
*/
private $commands = array();
public function __construct(Daemon $daemon) {
$this->daemon = $daemon;
}
public function __destruct() {
unset($this->daemon);
}
/**
* Called on Construct or Init
* @return void
*/
public function setup() {
$this->socket = socket_create(AF_INET, SOCK_STREAM, 0);
if (!socket_bind($this->socket, $this->ip, $this->port)) {
$errno = socket_last_error();
$this->error(sprintf('Could not bind to address %s:%s [%s] %s', $this->ip, $this->port, $errno, socket_strerror($errno)));
throw new Exception('Could not start server.');
}
socket_listen($this->socket);
$this->daemon->on(Daemon::ON_POSTEXECUTE, array($this, 'run'));
}
/**
* Called on Destruct
* @return void
*/
public function teardown() {
foreach(array_keys($this->clients) as $slot)
$this->disconnect($slot);
@ socket_shutdown($this->socket, 1);
usleep(500);
@ socket_shutdown($this->socket, 0);
@ socket_close($this->socket);
$this->socket = null;
}
/**
* This is called during object construction to validate any dependencies
* NOTE: At a minimum you should ensure that if $errors is not empty that you pass it along as the return value.
* @return Array Return array of error messages (Think stuff like "GD Library Extension Required" or "Cannot open /tmp for Writing") or an empty array
*/
public function check_environment(array $errors = array()) {
if (!is_callable('socket_create'))
$errors[] = 'Socket support is currently unavailable: You must add the php_sockets extension to your php.ini or recompile php with the --enable-sockets option set';
return $errors;
}
/**
* Add a Command object to the command queue. Input from a client is evaluated against these commands
* in the order they are added
*
* @param Command $command
*/
public function addCommand(Command $command) {
$this->commands[] = $command;
return $this;
}
/**
* An alternative to addCommand - a simple factory for Command objects.
* @param $regex
* @param $callable
*/
public function newCommand($regex, $callable) {
$cmd = new Command();
$cmd->regex = $regex;
$cmd->callable = $callable;
return $this->addCommand($cmd);
}
public function run() {
// Build an array of sockets and select any with pending I/O
$read = array (
0 => $this->socket
);
foreach($this->clients as $client)
$read[] = $client->socket;
$result = @ socket_select($read, $write = null, $except = null, $this->blocking ? null : 1);
if ($result === false || ($result === 0 && $this->blocking)) {
$this->error('Socket Select Interruption: ' . socket_strerror(socket_last_error()));
return false;
}
// If the master socket is in the $read array, there's a pending connection
if (in_array($this->socket, $read))
$this->connect();
// Handle input from sockets in the $read array.
$daemon = $this->daemon;
$printer = function($str) use ($daemon) {
$daemon->log($str, 'SocketServer');
};
foreach($this->clients as $slot => $client) {
if (!in_array($client->socket, $read))
continue;
$input = socket_read($client->socket, $this->max_read);
if ($input === null) {
$this->disconnect($slot);
continue;
}
$this->command($input, array($client->write, $printer));
}
}
private function connect() {
$slot = $this->slot();
if ($slot === null)
throw new Exception(sprintf('%s Failed - Maximum number of connections has been reached.', __METHOD__));
$this->debug("Creating New Connection");
$client = new \stdClass();
$client->socket = socket_accept($this->socket);
if (empty($client->socket))
throw new Exception(sprintf('%s Failed - socket_accept failed with error: %s', __METHOD__, socket_last_error()));
socket_getpeername($client->socket, $client->ip);
$client->write = function($string, $term = "\r\n") use($client) {
if($term)
$string .= $term;
return socket_write($client->socket, $string, strlen($string));
};
$this->clients[$slot] = $client;
// @todo clean this up
$daemon = $this->daemon;
$this->command(self::COMMAND_CONNECT, array($client->write, function($str) use ($daemon) {
$daemon->log($str, 'SocketServer');
}));
}
private function command($input, array $args = array()) {
foreach($this->commands as $command)
if($command->match($input, $args) && $command->exclusive)
break;
}
private function disconnect($slot) {
$daemon = $this->daemon;
$this->command(self::COMMAND_DISCONNECT, array($this->clients[$slot]->write, function($str) use ($daemon) {
$daemon->log($str, 'SocketServer');
}));
@ socket_shutdown($this->clients[$slot]->socket, 1);
usleep(500);
@ socket_shutdown($this->clients[$slot]->socket, 0);
@ socket_close($this->clients[$slot]->socket);
unset($this->clients[$slot]);
}
private function slot() {
for($i=0; $i < $this->max_clients; $i++ )
if (empty($this->clients[$i]))
return $i;
return null;
}
private function debug($message) {
if (!$this->debug)
return;
$this->daemon->debug($message, 'SocketServer');
}
private function error($message) {
$this->daemon->error($message, 'SocketServer');
}
private function log($message) {
$this->daemon->log($message, 'SocketServer');
}
}
|
#include "bitcoinunits.h"
#include <QStringList>
BitcoinUnits::BitcoinUnits(QObject *parent):
QAbstractListModel(parent),
unitlist(availableUnits())
{
}
QList<BitcoinUnits::Unit> BitcoinUnits::availableUnits()
{
QList<BitcoinUnits::Unit> unitlist;
unitlist.append(BTC);
unitlist.append(mBTC);
unitlist.append(uBTC);
return unitlist;
}
bool BitcoinUnits::valid(int unit)
{
switch(unit)
{
case BTC:
case mBTC:
case uBTC:
return true;
default:
return false;
}
}
QString BitcoinUnits::name(int unit)
{
switch(unit)
{
case BTC: return QString("LTCC");
case mBTC: return QString("mLTCC");
case uBTC: return QString::fromUtf8("μLTCC");
default: return QString("???");
}
}
QString BitcoinUnits::description(int unit)
{
switch(unit)
{
case BTC: return QString("Litecoin Classic");
case mBTC: return QString("milli Litecoin Classic (1 / 1,000)");
case uBTC: return QString("micro Litecoin Classic (1 / 1,000,000)");
default: return QString("???");
}
}
//a single unit (.00000001) of Litecoin Classic is called a "wander."
qint64 BitcoinUnits::factor(int unit)
{
switch(unit)
{
case BTC: return 100000000;
case mBTC: return 100000;
case uBTC: return 100;
default: return 100000000;
}
}
int BitcoinUnits::amountDigits(int unit)
{
switch(unit)
{
case BTC: return 8; // 21,000,000 (# digits, without commas)
case mBTC: return 11; // 21,000,000,000
case uBTC: return 14; // 21,000,000,000,000
default: return 0;
}
}
int BitcoinUnits::decimals(int unit)
{
switch(unit)
{
case BTC: return 8;
case mBTC: return 5;
case uBTC: return 2;
default: return 0;
}
}
QString BitcoinUnits::format(int unit, qint64 n, bool fPlus)
{
// Note: not using straight sprintf here because we do NOT want
// localized number formatting.
if(!valid(unit))
return QString(); // Refuse to format invalid unit
qint64 coin = factor(unit);
int num_decimals = decimals(unit);
qint64 n_abs = (n > 0 ? n : -n);
qint64 quotient = n_abs / coin;
qint64 remainder = n_abs % coin;
QString quotient_str = QString::number(quotient);
QString remainder_str = QString::number(remainder).rightJustified(num_decimals, '0');
// Right-trim excess 0's after the decimal point
int nTrim = 0;
for (int i = remainder_str.size()-1; i>=2 && (remainder_str.at(i) == '0'); --i)
++nTrim;
remainder_str.chop(nTrim);
if (n < 0)
quotient_str.insert(0, '-');
else if (fPlus && n > 0)
quotient_str.insert(0, '+');
return quotient_str + QString(".") + remainder_str;
}
QString BitcoinUnits::formatWithUnit(int unit, qint64 amount, bool plussign)
{
return format(unit, amount, plussign) + QString(" ") + name(unit);
}
bool BitcoinUnits::parse(int unit, const QString &value, qint64 *val_out)
{
if(!valid(unit) || value.isEmpty())
return false; // Refuse to parse invalid unit or empty string
int num_decimals = decimals(unit);
QStringList parts = value.split(".");
if(parts.size() > 2)
{
return false; // More than one dot
}
QString whole = parts[0];
QString decimals;
if(parts.size() > 1)
{
decimals = parts[1];
}
if(decimals.size() > num_decimals)
{
return false; // Exceeds max precision
}
bool ok = false;
QString str = whole + decimals.leftJustified(num_decimals, '0');
if(str.size() > 18)
{
return false; // Longer numbers will exceed 63 bits
}
qint64 retvalue = str.toLongLong(&ok);
if(val_out)
{
*val_out = retvalue;
}
return ok;
}
int BitcoinUnits::rowCount(const QModelIndex &parent) const
{
Q_UNUSED(parent);
return unitlist.size();
}
QVariant BitcoinUnits::data(const QModelIndex &index, int role) const
{
int row = index.row();
if(row >= 0 && row < unitlist.size())
{
Unit unit = unitlist.at(row);
switch(role)
{
case Qt::EditRole:
case Qt::DisplayRole:
return QVariant(name(unit));
case Qt::ToolTipRole:
return QVariant(description(unit));
case UnitRole:
return QVariant(static_cast<int>(unit));
}
}
return QVariant();
}
|
namespace AgileObjects.AgileMapper.Api.Configuration.Projection
{
<summary>
Enables chaining of configurations for the same source and result type.
</summary>
<typeparam name="TSourceElement">The source type to which the configuration should apply.</typeparam>
<typeparam name="TResultElement">The result type to which the configuration should apply.</typeparam>
public interface <API key><TSourceElement, TResultElement>
{
<summary>
Perform another configuration of how this mapper projects to and from the source and result types
being configured. This property exists purely to provide a more fluent configuration interface.
</summary>
<API key><TSourceElement, TResultElement> And { get; }
<summary>
Perform an alternative configuration of how this mapper projects to and from the source and result
types being configured. This property exists purely to provide a more fluent configuration interface.
</summary>
<API key><TSourceElement, TResultElement> But { get; }
}
}
|
#include <string>
#include <vector>
using std::string;
using std::vector;
// StrUtil class
class StrUtils
{
public:
/**Function used to trim empty character
* from begin and end of the string
* @param string& string to trim
* @return string& trimed tring, same object of parameter
*/
static string trim(string&);
/**Find if the given string is peresented
* in the given array
* @param const int char* array length
* @param const char*[] char* array, used to store string ary
* @return -1 if not found, otherwise return index
*/
static int indexOf(vector<string>&, string&);
static int indexOf(const int, const char*[], const char*);
static bool is_number(const std::string& s);
private:
static bool isEmpChar(const char);
//static const char m_empChar[];
//static const int m_empLen;
}; //class strutil
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace SetupEnviroment
{
class Application
{
public static void Main(string[] args)
{
NameSelector.DoExample();
//IdSelector.Main();
//NoSuchElement.DoExample();
Console.ReadKey();
}
}
}
|
using System;
using System.Collections.Generic;
using System.Dynamic;
using System.Reflection;
using Newtonsoft.Json;
namespace HMS.SP{
<summary>
<para>https://msdn.microsoft.com/en-us/library/office/dn600183.aspx#bk_Notes</para>
</summary>
public class Implementationnotes : SPBase{
[JsonProperty("__HMSError")]
public HMS.Util.__HMSError __HMSError_ { set; get; }
[JsonProperty("__status")]
public SP.__status __status_ { set; get; }
[JsonProperty("__deferred")]
public SP.__deferred __deferred_ { set; get; }
[JsonProperty("__metadata")]
public SP.__metadata __metadata_ { set; get; }
public Dictionary<string, string> __rest;
// no properties found
<summary>
<para> Endpoints </para>
</summary>
static string[] endpoints = {
};
public Implementationnotes(ExpandoObject expObj)
{
try
{
var use_EO = ((dynamic)expObj).entry.content.properties;
HMS.SP.SPUtil.expando2obj(use_EO, this, typeof(Implementationnotes));
}
catch (Exception ex)
{
}
}
// used by Newtonsoft.JSON
public Implementationnotes()
{
}
public Implementationnotes(string json)
{
if( json == String.Empty )
return;
dynamic jobject = Newtonsoft.Json.JsonConvert.DeserializeObject(json);
dynamic refObj = jobject;
if (jobject.d != null)
refObj = jobject.d;
string errInfo = "";
if (refObj.results != null)
{
if (refObj.results.Count > 1)
errInfo = "Result is Collection, only 1. entry displayed.";
refObj = refObj.results[0];
}
List<string> usedFields = new List<string>();
usedFields.Add("__HMSError");
HMS.SP.SPUtil.dyn_ValueSet("__HMSError", refObj, this);
usedFields.Add("__deferred");
this.__deferred_ = new SP.__deferred(HMS.SP.SPUtil.dyn_toString(refObj.__deferred));
usedFields.Add("__metadata");
this.__metadata_ = new SP.__metadata(HMS.SP.SPUtil.dyn_toString(refObj.__metadata));
this.__rest = new Dictionary<string, string>();
var dyn = ((Newtonsoft.Json.Linq.JContainer)refObj).First;
while (dyn != null)
{
string Name = ((Newtonsoft.Json.Linq.JProperty)dyn).Name;
string Value = ((Newtonsoft.Json.Linq.JProperty)dyn).Value.ToString();
if ( !usedFields.Contains( Name ))
this.__rest.Add( Name, Value);
dyn = dyn.Next;
}
if( errInfo != "")
this.__HMSError_.info = errInfo;
}
}
}
|
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Web.UI;
using System.Web.UI.WebControls;
using Vevo;
using Vevo.Domain.DataInterfaces;
using Vevo.Shared.Utilities;
using Vevo.WebAppLib;
using Vevo.Base.Domain;
public partial class <API key> : Vevo.WebUI.International.<API key>, ISearchFilter
{
private NameValueCollection FieldTypes
{
get
{
if (ViewState["FieldTypes"] == null)
ViewState["FieldTypes"] = new NameValueCollection();
return (NameValueCollection) ViewState["FieldTypes"];
}
}
private string <API key>( bool textPanel, bool boolPanel, bool valueRangePanel, bool dateRangePanel )
{
string script;
if (textPanel)
script = String.Format( "document.getElementById('{0}').style.display = '';", uxTextPanel.ClientID );
else
script = String.Format( "document.getElementById('{0}').style.display = 'none';", uxTextPanel.ClientID );
if (boolPanel)
script += String.Format( "document.getElementById('{0}').style.display = '';", uxBooleanPanel.ClientID );
else
script += String.Format( "document.getElementById('{0}').style.display = 'none';", uxBooleanPanel.ClientID );
if (valueRangePanel)
script += String.Format( "document.getElementById('{0}').style.display = '';", uxValueRangePanel.ClientID );
else
script += String.Format( "document.getElementById('{0}').style.display = 'none';", uxValueRangePanel.ClientID );
if (dateRangePanel)
script += String.Format( "document.getElementById('{0}').style.display = '';", uxDateRangePanel.ClientID );
else
script += String.Format( "document.getElementById('{0}').style.display = 'none';", uxDateRangePanel.ClientID );
return script;
}
private void ShowTextFilterInput()
{
uxTextPanel.Style.Add( HtmlTextWriterStyle.Display, "" );
uxBooleanPanel.Style.Add( HtmlTextWriterStyle.Display, "none" );
uxValueRangePanel.Style.Add( HtmlTextWriterStyle.Display, "none" );
uxDateRangePanel.Style.Add( HtmlTextWriterStyle.Display, "none" );
}
private void <API key>()
{
uxTextPanel.Style.Add( HtmlTextWriterStyle.Display, "none" );
uxBooleanPanel.Style.Add( HtmlTextWriterStyle.Display, "" );
uxValueRangePanel.Style.Add( HtmlTextWriterStyle.Display, "none" );
uxDateRangePanel.Style.Add( HtmlTextWriterStyle.Display, "none" );
}
private void <API key>()
{
uxTextPanel.Style.Add( HtmlTextWriterStyle.Display, "none" );
uxBooleanPanel.Style.Add( HtmlTextWriterStyle.Display, "none" );
uxValueRangePanel.Style.Add( HtmlTextWriterStyle.Display, "" );
uxDateRangePanel.Style.Add( HtmlTextWriterStyle.Display, "none" );
}
private void <API key>()
{
uxTextPanel.Style.Add( HtmlTextWriterStyle.Display, "none" );
uxBooleanPanel.Style.Add( HtmlTextWriterStyle.Display, "none" );
uxValueRangePanel.Style.Add( HtmlTextWriterStyle.Display, "none" );
uxDateRangePanel.Style.Add( HtmlTextWriterStyle.Display, "" );
}
private void HideAllInput()
{
uxTextPanel.Style.Add( HtmlTextWriterStyle.Display, "none" );
uxBooleanPanel.Style.Add( HtmlTextWriterStyle.Display, "none" );
uxValueRangePanel.Style.Add( HtmlTextWriterStyle.Display, "none" );
uxDateRangePanel.Style.Add( HtmlTextWriterStyle.Display, "none" );
}
private void <API key>()
{
string script = "if(this.value == ''){ javascript:__doPostBack('" + uxFilterDrop.UniqueID + "',''); }";
foreach (ListItem item in uxFilterDrop.Items)
{
switch (ParseSearchType( FieldTypes[item.Value] ))
{
case SearchFilter.SearchFilterType.Text:
script += "if(this.value == '" + item.Value + "'){" + <API key>( true, false, false, false ) + "}";
break;
case SearchFilter.SearchFilterType.Boolean:
script += "if(this.value == '" + item.Value + "'){" + <API key>( false, true, false, false ) + "}";
break;
case SearchFilter.SearchFilterType.ValueRange:
script += "if(this.value == '" + item.Value + "'){" + <API key>( false, false, true, false ) + "}";
break;
case SearchFilter.SearchFilterType.Date:
script += "if(this.value == '" + item.Value + "'){" + <API key>( false, false, false, true ) + "}";
break;
}
}
script += "document.getElementById( '" + uxValueText.ClientID + "' ).value = '';";
script += "document.getElementById( '" + uxBooleanDrop.ClientID + "' ).value = 'True';";
script += "document.getElementById( '" + uxLowerText.ClientID + "' ).value = '';";
script += "document.getElementById( '" + uxUpperText.ClientID + "' ).value = '';";
script += "document.getElementById( '" + uxStartDateText.ClientID + "' ).value = '';";
script += "document.getElementById( '" + uxEndDateText.ClientID + "' ).value = '';";
uxFilterDrop.Attributes.Add( "onchange", script );
}
private string GetFilterType( Type dataType )
{
string type;
if (dataType == Type.GetType( "System.Byte" ) ||
dataType == Type.GetType( "System.SByte" ) ||
dataType == Type.GetType( "System.Char" ) ||
dataType == Type.GetType( "System.String" ))
{
type = SearchFilter.SearchFilterType.Text.ToString();
}
else if (dataType == Type.GetType( "System.Boolean" ))
{
type = SearchFilter.SearchFilterType.Boolean.ToString();
}
else if (
dataType == Type.GetType( "System.Decimal" ) ||
dataType == Type.GetType( "System.Double" ) ||
dataType == Type.GetType( "System.Int16" ) ||
dataType == Type.GetType( "System.Int32" ) ||
dataType == Type.GetType( "System.Int64" ) ||
dataType == Type.GetType( "System.UInt16" ) ||
dataType == Type.GetType( "System.UInt32" ) ||
dataType == Type.GetType( "System.UInt64" ))
{
type = SearchFilter.SearchFilterType.ValueRange.ToString();
}
else if (dataType == Type.GetType( "System.DateTime" ))
{
type = SearchFilter.SearchFilterType.Date.ToString();
}
else
{
type = String.Empty;
}
return type;
}
private SearchFilter.SearchFilterType ParseSearchType( string searchFilterType )
{
SearchFilter.SearchFilterType type;
if (String.Compare( searchFilterType, SearchFilter.SearchFilterType.Text.ToString(), true ) == 0)
type = SearchFilter.SearchFilterType.Text;
else if (String.Compare( searchFilterType, SearchFilter.SearchFilterType.Boolean.ToString(), true ) == 0)
type = SearchFilter.SearchFilterType.Boolean;
else if (String.Compare( searchFilterType, SearchFilter.SearchFilterType.ValueRange.ToString(), true ) == 0)
type = SearchFilter.SearchFilterType.ValueRange;
else if (String.Compare( searchFilterType, SearchFilter.SearchFilterType.Date.ToString(), true ) == 0)
type = SearchFilter.SearchFilterType.Date;
else
type = SearchFilter.SearchFilterType.None;
return type;
}
private void RemoveSearchFilter()
{
SearchFilterObj = SearchFilter.GetFactory()
.Create();
uxMessageLabel.Text = String.Empty;
}
private void <API key>()
{
WebUtilities.TieButton( this.Page, uxValueText, <API key> );
WebUtilities.TieButton( this.Page, uxLowerText, <API key> );
WebUtilities.TieButton( this.Page, uxUpperText, <API key> );
WebUtilities.TieButton( this.Page, uxStartDateText, <API key> );
WebUtilities.TieButton( this.Page, uxEndDateText, <API key> );
}
private void <API key>( string fieldName, string value )
{
if (!String.IsNullOrEmpty( value ))
{
uxMessageLabel.Text =
String.Format( Resources.<API key>.TextMessage,
value, fieldName );
}
}
private void <API key>( string fieldName, string value )
{
bool boolValue;
if (Boolean.TryParse( value, out boolValue ))
{
uxMessageLabel.Text =
String.Format( Resources.<API key>.BooleanMessage,
ConvertUtilities.ToYesNo( boolValue ), fieldName );
}
}
private void <API key>( string fieldName, string value1, string value2 )
{
if (!String.IsNullOrEmpty( value1 ) && !String.IsNullOrEmpty( value2 ))
{
uxMessageLabel.Text =
String.Format( Resources.<API key>.<API key>,
value1, value2, fieldName );
}
else if (!String.IsNullOrEmpty( value1 ))
{
uxMessageLabel.Text =
String.Format( Resources.<API key>.<API key>,
value1, fieldName );
}
else if (!String.IsNullOrEmpty( value2 ))
{
uxMessageLabel.Text =
String.Format( Resources.<API key>.<API key>,
value2, fieldName );
}
}
private void RestoreControls()
{
uxFilterDrop.SelectedValue = SearchFilterObj.FieldName;
switch (SearchFilterObj.FilterType)
{
case SearchFilter.SearchFilterType.Text:
uxValueText.Text = SearchFilterObj.Value1;
<API key>( SearchFilterObj.FieldName, SearchFilterObj.Value1 );
break;
case SearchFilter.SearchFilterType.Boolean:
uxBooleanDrop.SelectedValue = ConvertUtilities.ToBoolean( SearchFilterObj.Value1 ).ToString();
<API key>( SearchFilterObj.FieldName, SearchFilterObj.Value1 );
break;
case SearchFilter.SearchFilterType.ValueRange:
uxLowerText.Text = SearchFilterObj.Value1;
uxUpperText.Text = SearchFilterObj.Value2;
<API key>( SearchFilterObj.FieldName, SearchFilterObj.Value1, SearchFilterObj.Value2 );
break;
case SearchFilter.SearchFilterType.Date:
uxStartDateText.Text = ConvertUtilities.ToDateTime( SearchFilterObj.Value1 ).ToString( "MMMM d,yyyy" );
uxEndDateText.Text = ConvertUtilities.ToDateTime( SearchFilterObj.Value2 ).ToString( "MMMM d,yyyy" );
<API key>( SearchFilterObj.FieldName, uxStartDateText.Text, uxEndDateText.Text );
break;
}
}
private void ShowSelectedInput( SearchFilter.SearchFilterType filterType )
{
switch (filterType)
{
case SearchFilter.SearchFilterType.Text:
ShowTextFilterInput();
break;
case SearchFilter.SearchFilterType.Boolean:
<API key>();
break;
case SearchFilter.SearchFilterType.ValueRange:
<API key>();
break;
case SearchFilter.SearchFilterType.Date:
<API key>();
break;
default:
HideAllInput();
RemoveSearchFilter();
break;
}
}
private bool IsShowAllSelected()
{
return String.IsNullOrEmpty( uxFilterDrop.SelectedValue );
}
private void <API key>()
{
ShowSelectedInput( SearchFilterObj.FilterType );
RestoreControls();
}
protected void Page_Load( object sender, EventArgs e )
{
<API key>();
if (!IsPostBack)
{
<API key>();
}
}
protected void <API key>( object sender, EventArgs e )
{
ShowSelectedInput( ParseSearchType( FieldTypes[uxFilterDrop.SelectedValue] ) );
if (IsShowAllSelected())
OnBubbleEvent( e );
}
protected void <API key>( object sender, EventArgs e )
{
PopulateValueFilter(
SearchFilter.SearchFilterType.Text,
uxFilterDrop.SelectedValue,
uxValueText.Text,
e );
}
protected void <API key>( object sender, EventArgs e )
{
PopulateValueFilter(
SearchFilter.SearchFilterType.Boolean,
uxFilterDrop.SelectedValue,
uxBooleanDrop.SelectedValue,
e );
}
protected void <API key>( object sender, EventArgs e )
{
<API key>(
SearchFilter.SearchFilterType.ValueRange,
uxFilterDrop.SelectedValue,
uxLowerText.Text,
uxUpperText.Text,
e );
}
protected void <API key>( object sender, EventArgs e )
{
<API key>(
SearchFilter.SearchFilterType.Date,
uxFilterDrop.SelectedValue,
uxStartDateText.Text,
uxEndDateText.Text,
e );
}
private void PopulateValueFilter( SearchFilter.SearchFilterType typeField,
string value, string val1, EventArgs e )
{
SearchFilterObj = SearchFilter.GetFactory()
.WithFilterType( typeField )
.WithFieldName( value )
.WithValue1( val1 )
.Create();
if (typeField == SearchFilter.SearchFilterType.Text)
<API key>( SearchFilterObj.FieldName, SearchFilterObj.Value1 );
else if (typeField == SearchFilter.SearchFilterType.Boolean)
<API key>( SearchFilterObj.FieldName, SearchFilterObj.Value1 );
// Propagate event to parent
OnBubbleEvent( e );
}
private void <API key>( SearchFilter.SearchFilterType typeField,
string value, string val1, string val2, EventArgs e )
{
SearchFilterObj = SearchFilter.GetFactory()
.WithFilterType( typeField )
.WithFieldName( value )
.WithValue1( val1 )
.WithValue2( val2 )
.Create();
<API key>( SearchFilterObj.FieldName, SearchFilterObj.Value1, SearchFilterObj.Value2 );
// Propagate event to parent
OnBubbleEvent( e );
}
public void SetUpSchema(
IList<TableSchemaItem> columnList,
params string[] excludingColumns )
{
uxFilterDrop.Items.Clear();
FieldTypes.Clear();
uxFilterDrop.Items.Add( new ListItem( Resources.<API key>.FilterShowAll, String.Empty ) );
FieldTypes[Resources.<API key>.FilterShowAll] = SearchFilter.SearchFilterType.None.ToString();
for (int i = 0; i < columnList.Count; i++)
{
if (!StringUtilities.IsStringInArray( excludingColumns, columnList[i].ColumnName, true ))
{
string type = GetFilterType( columnList[i].DataType );
if (!String.IsNullOrEmpty( type ))
{
uxFilterDrop.Items.Add( columnList[i].ColumnName );
FieldTypes[columnList[i].ColumnName] = type;
}
}
}
<API key>();
}
public void SetUpSchema(
IList<TableSchemaItem> columnList,
NameValueCollection renameList,
params string[] excludingColumns )
{
SetUpSchema( columnList, excludingColumns );
for (int i = 0; i < renameList.Count; i++)
{
for (int j = 0; j < columnList.Count; j++)
{
if (renameList.AllKeys[i].ToString() == columnList[j].ColumnName)
{
string type = GetFilterType( columnList[j].DataType );
if (!String.IsNullOrEmpty( type ))
{
uxFilterDrop.Items[j + 1].Text = renameList[i].ToString();
uxFilterDrop.Items[j + 1].Value = renameList.AllKeys[i].ToString();
FieldTypes[renameList[i].ToString()] = type;
}
}
}
}
<API key>();
}
public SearchFilter SearchFilterObj
{
get
{
if (ViewState["SearchFilter"] == null)
return SearchFilter.GetFactory()
.Create();
else
return (SearchFilter) ViewState["SearchFilter"];
}
set
{
ViewState["SearchFilter"] = value;
}
}
public void ClearFilter()
{
RemoveSearchFilter();
uxFilterDrop.SelectedValue = "";
HideAllInput();
}
public void UpdateBrowseQuery( UrlQuery urlQuery )
{
urlQuery.RemoveQuery( "Type" );
urlQuery.RemoveQuery( "FieldName" );
urlQuery.RemoveQuery( "FieldValue" );
urlQuery.RemoveQuery( "Value1" );
urlQuery.RemoveQuery( "Value2" );
if (SearchFilterObj.FilterType != SearchFilter.SearchFilterType.None)
{
urlQuery.AddQuery( "Type", SearchFilterObj.FilterType.ToString() );
urlQuery.AddQuery( "FieldName", SearchFilterObj.FieldName );
urlQuery.AddQuery( "Value1", SearchFilterObj.Value1 );
if (!String.IsNullOrEmpty( SearchFilterObj.Value2 ))
urlQuery.AddQuery( "Value2", SearchFilterObj.Value2 );
}
}
}
|
#include <stdio.h>
#include <stdlib.h>
static inline void swap(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
static int <API key>(int* nums, int numsSize)
{
if (numsSize == 0) {
return 1;
}
int i = 0;
while (i < numsSize) {
/* nums[i] should be i+1 and nums[nums[i] - 1] should be nums[i] */
if (nums[i] != i + 1 && nums[i] > 0 && nums[i] <= numsSize && nums[nums[i] - 1] != nums[i]) {
/* let nums[nums[i] - 1] = nums[i] */
swap(nums + i, nums + nums[i] - 1);
} else {
i++;
}
}
for (i = 0; i < numsSize; i++) {
if (nums[i] != i + 1) {
break;
}
}
return i + 1;
}
int main(int argc, char **argv)
{
int i, count = argc - 1;
int *nums = malloc(count * sizeof(int));
for (i = 0; i < count; i++) {
nums[i] = atoi(argv[i + 1]);
}
printf("%d\n", <API key>(nums, count));
return 0;
}
|
<?php
namespace Eeemarv\EeemarvBundle\Command;
use Symfony\Bundle\FrameworkBundle\Command\<API key>;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use MimeMailParser\Parser;
use MimeMailParser\Attachment;
class MailCommand extends <API key>
{
private $returnErrors = array();
private $domain = 'localhost';
protected function configure()
{
$this
->setName('eeemarv:mail')
->setDescription('pipes mails. use -q option. mailParse php extension has to be enabled.')
->addArgument('path', InputArgument::OPTIONAL, 'The path to the email-file.')
;
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$parser = new Parser();
$path = $input->getArgument('path');
if ($path){
$parser->setPath($path);
} else {
$parser->setStream(fopen('php://stdin', 'r'));
}
if ($parser->getHeader('cc')){
exit; // feedback error (todo)
}
$subject = $parser->getHeader('subject');
if (!$subject){
exit; // feedback error (todo)
}
list($toId, $toDomain) = $this->decompose($parser->getHeader('to'));
list($fromId, $fromDomain) = $this->decompose($parser->getHeader('from'), $toDomain);
list($uniqueId, $domain) = $this->decompose($parser->getHeader('message-id'), $toDomain);
$returnPath = $parser->getHeader('return-path');
$body = $parser->getMessageBody('html');
if (!$body){
$body = $parser->getMessageBody('text');
if (!$body){
exit;
}
}
/*
$attachments = $parser->getAttachments();
foreach ($attachments as $attachment)
{
$filename = $attachment->filename;
if ($f = fopen($save_dir.$filename, 'w'))
{
while($bytes = $attachment->read())
{
fwrite($f, $bytes);
}
fclose($f);
}
}
*/
$output->writeln('from id:'.$fromId);
$output->writeln('to id:'.$toId);
$output->writeln('subject:'.$subject);
$output->writeln('return-path:'.$returnPath);
$output->writeln('message-id:'.$uniqueId.'@'.$domain);
$output->writeln('unique-id:'.$uniqueId);
$output->writeln('domain:'.$domain);
$output->writeln('body:'.$body);
$output->writeln('html:'.$html);
}
private function decompose($address, $compareDomain = null)
{
$addressAry = <API key>($address);
if (!sizeOf($addressAry)){ // missing address
exit;
}
if (sizeOf($addressAry) > 1){ // more than one address (feedback error - todo )
exit;
}
$address = $addressAry[0]['address'];
list($id, $domain) = explode('@', $address);
if (!$id || !$domain || $domain == $compareDomain){
exit;
}
return array($id, $domain);
}
}
|
define([
"./core",
"./var/slice",
"./callbacks"
], function( jQuery, slice ) {
jQuery.extend({
Deferred: function( func ) {
var tuples = [
// action, add listener, listener list, final state
[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
[ "notify", "progress", jQuery.Callbacks("memory") ]
],
state = "pending",
promise = {
state: function() {
return state;
},
always: function() {
deferred.done( arguments ).fail( arguments );
return this;
},
then: function( /* fnDone, fnFail, fnProgress */ ) {
var fns = arguments;
return jQuery.Deferred(function( newDefer ) {
jQuery.each( tuples, function( i, tuple ) {
var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
// deferred[ done | fail | progress ] for forwarding actions to newDefer
deferred[ tuple[1] ](function() {
var returned = fn && fn.apply( this, arguments );
if ( returned && jQuery.isFunction( returned.promise ) ) {
returned.promise()
.done( newDefer.resolve )
.fail( newDefer.reject )
.progress( newDefer.notify );
} else {
newDefer[ tuple[ 0 ] + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
}
});
});
fns = null;
}).promise();
},
// Get a promise for this deferred
// If obj is provided, the promise aspect is added to the object
promise: function( obj ) {
return obj != null ? jQuery.extend( obj, promise ) : promise;
}
},
deferred = {};
// Keep pipe for back-compat
promise.pipe = promise.then;
// Add list-specific methods
jQuery.each( tuples, function( i, tuple ) {
var list = tuple[ 2 ],
stateString = tuple[ 3 ];
// promise[ done | fail | progress ] = list.add
promise[ tuple[1] ] = list.add;
// Handle state
if ( stateString ) {
list.add(function() {
// state = [ resolved | rejected ]
state = stateString;
// [ reject_list | resolve_list ].disable; progress_list.lock
}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
}
// deferred[ resolve | reject | notify ]
deferred[ tuple[0] ] = function() {
deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
return this;
};
deferred[ tuple[0] + "With" ] = list.fireWith;
});
// Make the deferred a promise
promise.promise( deferred );
// Call given func if any
if ( func ) {
func.call( deferred, deferred );
}
// All done!
return deferred;
},
// Deferred helper
when: function( subordinate /* , ..., subordinateN */ ) {
var i = 0,
resolveValues = slice.call( arguments ),
length = resolveValues.length,
// the count of uncompleted subordinates
remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
// Update function for both resolve and progress values
updateFunc = function( i, contexts, values ) {
return function( value ) {
contexts[ i ] = this;
values[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
if ( values === progressValues ) {
deferred.notifyWith( contexts, values );
} else if ( !( --remaining ) ) {
deferred.resolveWith( contexts, values );
}
};
},
progressValues, progressContexts, resolveContexts;
// Add listeners to Deferred subordinates; treat others as resolved
if ( length > 1 ) {
progressValues = new Array( length );
progressContexts = new Array( length );
resolveContexts = new Array( length );
for ( ; i < length; i++ ) {
if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
resolveValues[ i ].promise()
.done( updateFunc( i, resolveContexts, resolveValues ) )
.fail( deferred.reject )
.progress( updateFunc( i, progressContexts, progressValues ) );
} else {
--remaining;
}
}
}
// If we're not waiting on anything, resolve the master
if ( !remaining ) {
deferred.resolveWith( resolveContexts, resolveValues );
}
return deferred.promise();
}
});
return jQuery;
});
|
<reference path="../../../typings/index.d.ts" />
import * as React from 'react';
import * as ReactDOM from 'react-dom';
import { UserList } from '../components/users';
export class People extends React.Component<{}, {}> {
render () {
return (
<div className="row">
<div id="content">
<UserList />
</div>
</div>
);
}
}
|
var http = require("http");
var url = require("url");
function start(route, handle)
{
function onRequest(request, response)
{
var pathname = url.parse(request.url).pathname;
console.log("Request for " + pathname + " received.");
route(handle, pathname, response);
}
http.createServer(onRequest).listen(8888);
console.log("Server has started");
}
exports.start = start;
|
using DandelionWebSockets
import JSON
import Base.==
import DandelionSlack: on_event, on_reply, on_error, on_connect, on_disconnect,
EventTimestamp, RTMWebSocket, send_text, stop, RTMClient, makerequest,
wsconnect, HttpException
import DandelionWebSockets: @mock, @mockfunction, @expect, Throws, mock_match
import DandelionWebSockets: AbstractRetry, Retry, retry, reset, set_function
# A fake RTM event.
immutable FakeEvent <: DandelionSlack.OutgoingEvent
value::UTF8String
FakeEvent() = new("")
FakeEvent(a::ASCIIString) = new(utf8(a))
end
==(a::FakeEvent, b::FakeEvent) = a.value == b.value
DandelionSlack.serialize(event::FakeEvent) = Dict{AbstractString, Any}("value" => event.value)
test_event_1 = FakeEvent("bar")
test_event_2 = FakeEvent("baz")
# Also add equality for all events, for testing convenience.
macro eventeq(r::Expr)
quote
function $(esc(:(==)))(a::$r, b::$r)
if typeof(a) != typeof(b)
return false
end
for name in fieldnames(a)
af = getfield(a, name)
bf = getfield(b, name)
if isa(af, Nullable)
null_equals = isnull(af) && isnull(bf) || !isnull(af) && !isnull(bf) && get(af) == get(bf)
if !null_equals
return false
end
else
if af != bf
return false
end
end
end
return true
end
end
end
@eventeq DandelionSlack.OutgoingEvent
@eventeq DandelionSlack.Event
@eventeq DandelionSlack.EventError
function ==(a::RTMError, b::RTMError)
return a.code == b.code && a.msg == b.msg
end
# Implement a mock WebSocket client that stores the events we send.
@mock MockWSClient AbstractWSClient
ws_client = MockWSClient()
@mockfunction(ws_client,
send_text(::MockWSClient, ::UTF8String),
stop(::MockWSClient),
wsconnect(::MockWSClient, ::Requests.URI, ::WebSocketHandler))
# A mock RTMHandler to test that RTMWebSocket propagates messages correctly.
@mock MockRTMHandler RTMHandler
mock_handler = MockRTMHandler()
@mockfunction(mock_handler,
on_reply(::MockRTMHandler, ::Int64, ::DandelionSlack.Event),
on_event(::MockRTMHandler, ::DandelionSlack.Event),
on_error(::MockRTMHandler, e::EventError),
on_disconnect(::MockRTMHandler),
on_connect(::MockRTMHandler))
# Fake requests and mocking the makerequests function.
immutable FakeRequests <: AbstractHttp end
fake_requests = FakeRequests()
post(::FakeRequests, uri::AbstractString; args...) = nothing
abstract AbstractMocker
@mock Mocker AbstractMocker
mocker = Mocker()
@mockfunction mocker makerequest(::Any, ::FakeRequests)
@mock MockRetry AbstractRetry
mock_retry = MockRetry()
@mockfunction mock_retry retry(::MockRetry) reset(::MockRetry) set_function(::MockRetry, ::Function)
token = Token("ABCDEF")
ok_status = Status(true, Nullable{UTF8String}(utf8("")), Nullable{UTF8String}(utf8("")))
# `fake_url` is what we get back from Slck. `expected_fake_url` is what the Slack URL needs to be
# converted to, in order to send it into Requests.
fake_url = utf8("ws://some/url")
expected_fake_url = Requests.URI("http://some/url")
fake_self = Self(UserId("U0"), SlackName("User 0"), 123, utf8(""))
fake_team = Team(TeamId("T0"), SlackName("Team 0"), utf8(""), utf8(""))
<API key> = RtmStartResponse(fake_url, fake_self, fake_team,
[], [], [], Nullable{DandelionSlack.Mpim}(), [], [])
# Matching JSON
immutable JSONMatcher <: AbstractMatcher
object::Dict{Any, Any}
end
mock_match(m::JSONMatcher, v::AbstractString) = m.object == JSON.parse(v)
# Tests
facts("RTM event register") do
@fact DandelionSlack.find_event("message") --> MessageEvent
@fact DandelionSlack.find_event("nosuchevent") --> nothing
end
facts("RTM events") do
context("Event equality for testing") do
@fact MessageEvent("a", ChannelId("b"), UserId("U0"), EventTimestamp("123"))
MessageEvent("a", ChannelId("b"), UserId("U0"), EventTimestamp("123"))
@fact MessageEvent("a", ChannelId("b"), UserId("U0"), EventTimestamp("123")) !=
MessageEvent("b", ChannelId("c"), UserId("U0"), EventTimestamp("123")) --> true
@fact <API key>("a", ChannelId("b")) --> <API key>("a", ChannelId("b"))
@fact <API key>("a", ChannelId("b")) != <API key>("b", ChannelId("c")) --> true
end
context("Deserialize events") do
message_json = """{"id": 1, "type": "message", "text": "Hello",
"channel": "C0", "user": "U0", "ts": "123"}"""
message = DandelionSlack.deserialize(MessageEvent, message_json)
@fact message --> MessageEvent(utf8("Hello"), ChannelId("C0"), UserId("U0"), EventTimestamp("123"))
end
context("Propagate events from WebSocket to RTM") do
rtm_ws = RTMWebSocket(mock_retry)
attach(rtm_ws, mock_handler)
@expect mock_handler on_event(mock_handler,
MessageEvent(utf8("Hello"), ChannelId(utf8("C0")), UserId("U0"), EventTimestamp("123")))
on_text(rtm_ws, utf8("""{"type": "message", "channel": "C0",
"text": "Hello", "user": "U0", "ts": "123"}"""))
check(mock_handler)
check(mock_retry)
end
context("Message ack event") do
rtm_ws = RTMWebSocket(mock_retry)
attach(rtm_ws, mock_handler)
@expect mock_handler on_reply(mock_handler, 1,
MessageAckEvent(utf8("Hello"), Nullable(ChannelId("C0")), true, EventTimestamp("123")))
on_text(rtm_ws,
utf8("""{"reply_to": 1, "ok": true, "text": "Hello", "channel": "C0", "ts": "123"}"""))
check(mock_handler)
check(mock_retry)
end
context("Missing type key and not message ack") do
rtm_ws = RTMWebSocket(mock_retry)
attach(rtm_ws, mock_handler)
text = utf8("""{"reply_to": 1}""")
@expect mock_handler on_error(mock_handler, MissingTypeError(text))
on_text(rtm_ws, text)
check(mock_handler)
check(mock_retry)
end
context("Invalid JSON") do
rtm_ws = RTMWebSocket(mock_retry)
attach(rtm_ws, mock_handler)
text = utf8("""{"reply_to" foobarbaz""")
@expect mock_handler on_error(mock_handler, InvalidJSONError(text))
on_text(rtm_ws, text)
check(mock_handler)
check(mock_retry)
end
context("Unknown message type") do
rtm_ws = RTMWebSocket(mock_retry)
attach(rtm_ws, mock_handler)
text = utf8("""{"type": "nosuchtype"}""")
@expect mock_handler on_error(mock_handler, <API key>(text, utf8("nosuchtype")))
on_text(rtm_ws, text)
check(mock_handler)
check(mock_retry)
end
context("Missing required field") do
rtm_ws = RTMWebSocket(mock_retry)
attach(rtm_ws, mock_handler)
# No "text" field.
text = utf8("""{"type": "message", "channel": "C0", "user": "U0", "ts": "123"}""")
@expect mock_handler on_error(mock_handler, <API key>(utf8("text"), text, MessageEvent))
on_text(rtm_ws, text)
check(mock_handler)
check(mock_retry)
end
context("Error event from Slack") do
rtm_ws = RTMWebSocket(mock_retry)
attach(rtm_ws, mock_handler)
@expect mock_handler on_event(mock_handler, ErrorEvent(RTMError(1, "Reason")))
on_text(rtm_ws,
utf8("""{"type": "error", "error": {"code": 1, "msg": "Reason"}}"""))
check(mock_retry)
check(mock_handler)
end
context("Retry connection on WebSocket close") do
rtm_ws = RTMWebSocket(mock_retry)
attach(rtm_ws, mock_handler)
@expect mock_handler on_disconnect(mock_handler)
@expect mock_retry retry(mock_retry)
state_closed(rtm_ws)
check(mock_handler)
check(mock_retry)
end
context("Successful connection") do
rtm_ws = RTMWebSocket(mock_retry)
attach(rtm_ws, mock_handler)
@expect mock_handler on_connect(mock_handler)
@expect mock_retry reset(mock_retry)
state_open(rtm_ws)
check(mock_handler)
check(mock_retry)
end
# This only tests that the callback functions exist, not that they actually do anything.
# This is mostly for coverage.
context("Existence of the rest of WebSocketHandler interface functions") do
rtm_ws = RTMWebSocket(mock_retry)
attach(rtm_ws, mock_handler)
on_binary(rtm_ws, b"")
state_connecting(rtm_ws)
state_closing(rtm_ws)
check(mock_handler)
check(mock_retry)
end
end
facts("RTMClient") do
context("Send and receive events") do
@expect mock_retry set_function(mock_retry, TypeMatcher(Function))
rtm_client = RTMClient(token;
connection_retry=mock_retry, ws_client_factory=x -> ws_client)
attach(rtm_client, mock_handler)
# `<API key>` uses `fake_url` as the URL we should connect to.
@expect mocker makerequest(TypeMatcher(Any), fake_requests) (ok_status, <API key>)
@expect ws_client wsconnect(ws_client, Requests.URI(fake_url), rtm_client.rtm_ws)
rtm_connect(rtm_client; requests=fake_requests)
# We will send two events from server to client, a HelloEvent and a message "A message".
@expect mock_handler on_event(mock_handler, HelloEvent())
@expect mock_handler on_event(mock_handler,
MessageEvent("A message", ChannelId("C0"), UserId("U0"), EventTimestamp("12345.6789")))
first_id = 1
# ... then send one event from client to server, and then send the reply to that message.
@expect ws_client send_text(ws_client, JSONMatcher(Dict{Any, Any}(
"id" => first_id, "type" => "message", "text" => "Hello", "channel" => "C0")))
@expect mock_handler on_reply(mock_handler, first_id,
MessageAckEvent("Hello", Nullable(ChannelId("C0")), true, EventTimestamp("12345.6789")))
# These are fake events from the WebSocket
on_text(rtm_client.rtm_ws, utf8("""{"type": "hello"}"""))
on_text(rtm_client.rtm_ws, utf8(
"""{"type": "message", "text": "A message", "channel": "C0", "user": "U0", "ts": "12345.6789"}"""))
# Send a message, and then we fake a reply to it.
m_id1 = send_event(rtm_client, <API key>("Hello", ChannelId("C0")))
on_text(rtm_client.rtm_ws,
utf8("""{"ok": true, "reply_to": $(first_id), "text": "Hello", "channel": "C0", "ts": "12345.6789"}"""))
check(ws_client)
check(mocker)
check(mock_handler)
check(mock_retry)
end
context("Connection failed due to exception") do
@expect mock_retry set_function(mock_retry, TypeMatcher(Function))
rtm_client = RTMClient(token;
connection_retry=mock_retry,
ws_client_factory=x -> ws_client)
attach(rtm_client, mock_handler)
# `<API key>` uses `fake_url` as the URL we should connect to.
@expect mocker makerequest(TypeMatcher(Any), fake_requests) Throws(HttpException())
@expect mock_handler on_disconnect(mock_handler)
@expect mock_retry retry(mock_retry)
rtm_connect(rtm_client; requests=fake_requests)
check(ws_client)
check(mocker)
check(mock_handler)
check(mock_retry)
end
context("Set retry function to rtm_connect") do
@expect mock_retry set_function(mock_retry, TypeMatcher(Function))
rtm_client = RTMClient(token;
connection_retry=mock_retry,
ws_client_factory=x -> ws_client)
attach(rtm_client, mock_handler)
check(ws_client)
check(mocker)
check(mock_handler)
check(mock_retry)
end
context("Sending events") do
@expect mock_retry set_function(mock_retry, TypeMatcher(Function))
rtm = DandelionSlack.RTMClient(token;
connection_retry=mock_retry,
ws_client_factory=x -> ws_client)
attach(rtm, mock_handler)
@expect ws_client send_text(ws_client, JSONMatcher(
Dict{Any,Any}("id" => 1, "value" => test_event_1.value)))
@expect ws_client send_text(ws_client, JSONMatcher(
Dict{Any,Any}("id" => 2, "value" => test_event_2.value)))
DandelionSlack.send_event(rtm, test_event_1)
DandelionSlack.send_event(rtm, test_event_2)
check(mock_retry)
end
context("Send close on user request") do
@expect mock_retry set_function(mock_retry, TypeMatcher(Function))
rtm = DandelionSlack.RTMClient(token;
connection_retry=mock_retry,
ws_client_factory=x -> ws_client)
attach(rtm, mock_handler)
@expect ws_client stop(ws_client)
close(rtm)
check(mock_retry)
end
context("Increasing message id") do
@expect mock_retry set_function(mock_retry, TypeMatcher(Function))
rtm = DandelionSlack.RTMClient(token;
connection_retry=mock_retry,
ws_client_factory=x -> ws_client)
attach(rtm, mock_handler)
@expect ws_client send_text(ws_client, TypeMatcher(UTF8String))
@expect ws_client send_text(ws_client, TypeMatcher(UTF8String))
@expect ws_client send_text(ws_client, TypeMatcher(UTF8String))
message_id_1 = DandelionSlack.send_event(rtm, FakeEvent())
message_id_2 = DandelionSlack.send_event(rtm, FakeEvent())
message_id_3 = DandelionSlack.send_event(rtm, FakeEvent())
@fact message_id_1 < message_id_2 < message_id_3 --> true
check(mock_retry)
end
context("Throttling of events") do
throttling = 0.2
throttled_client = ThrottledWSClient(ws_client, throttling)
@expect mock_retry set_function(mock_retry, TypeMatcher(Function))
rtm_client = RTMClient(token;
connection_retry=mock_retry,
ws_client_factory=x -> throttled_client)
attach(rtm_client, mock_handler)
# `<API key>` uses `fake_url` as the URL we should connect to.
@expect mocker makerequest(TypeMatcher(Any), fake_requests) (ok_status, <API key>)
@expect ws_client wsconnect(ws_client, Requests.URI(fake_url), rtm_client.rtm_ws)
rtm_connect(rtm_client; requests=fake_requests)
# Send messages and verify that they are throttled.
@expect ws_client send_text(ws_client, TypeMatcher(UTF8String))
n = 5
for i = 1:n
send_event(rtm_client, <API key>("Hello", ChannelId("C0")))
end
sleep(0.01)
check(ws_client)
@expect ws_client send_text(ws_client, TypeMatcher(UTF8String))
# Wait for one throttling interval and verify that we haven't sent all messages yet.
sleep(throttling)
check(ws_client)
@expect ws_client send_text(ws_client, TypeMatcher(UTF8String))
@expect ws_client send_text(ws_client, TypeMatcher(UTF8String))
@expect ws_client send_text(ws_client, TypeMatcher(UTF8String))
# Sleep for the rest of the expected time and check that we have sent all messages.
sleep(throttling * (n - 2) + 0.05)
check(ws_client)
check(mocker)
check(mock_handler)
check(mock_retry)
end
end
|
// UIColor+Rainbow.h
// Rainbow UIColor Extension
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// all copies or substantial portions of the Software.
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#import <UIKit/UIKit.h>
@interface UIColor (Rainbow)
/*!
* Returns a UIColor object representing the color Acid Green, whose RBG values are (176, 191, 26), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) acidGreenColor;
/*!
* Returns a UIColor object representing the color Acid Green, whose RBG values are (176, 191, 26), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Aero, whose RBG values are (124, 185, 232), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) aeroColor;
/*!
* Returns a UIColor object representing the color Aero, whose RBG values are (124, 185, 232), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) aeroColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Aero Blue, whose RBG values are (201, 255, 229), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) aeroBlueColor;
/*!
* Returns a UIColor object representing the color Aero Blue, whose RBG values are (201, 255, 229), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color African Violet, whose RBG values are (178, 132, 190), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) africanVioletColor;
/*!
* Returns a UIColor object representing the color African Violet, whose RBG values are (178, 132, 190), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Air Force Blue (RAF), whose RBG values are (93, 138, 168), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Air Force Blue (RAF), whose RBG values are (93, 138, 168), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Air Force Blue (USAF), whose RBG values are (0, 48, 143), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Air Force Blue (USAF), whose RBG values are (0, 48, 143), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Air Superiority Blue, whose RBG values are (114, 160, 193), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Air Superiority Blue, whose RBG values are (114, 160, 193), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Alabama Crimson, whose RBG values are (175, 0, 42), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) alabamaCrimsonColor;
/*!
* Returns a UIColor object representing the color Alabama Crimson, whose RBG values are (175, 0, 42), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Alice Blue, whose RBG values are (240, 248, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) aliceBlueColor;
/*!
* Returns a UIColor object representing the color Alice Blue, whose RBG values are (240, 248, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Alizarin Crimson, whose RBG values are (227, 38, 54), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Alizarin Crimson, whose RBG values are (227, 38, 54), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Alloy Orange, whose RBG values are (196, 98, 16), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) alloyOrangeColor;
/*!
* Returns a UIColor object representing the color Alloy Orange, whose RBG values are (196, 98, 16), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Almond (Crayola), whose RBG values are (239, 222, 205), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) almondCrayolaColor;
/*!
* Returns a UIColor object representing the color Almond (Crayola), whose RBG values are (239, 222, 205), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amaranth, whose RBG values are (229, 43, 80), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amaranthColor;
/*!
* Returns a UIColor object representing the color Amaranth, whose RBG values are (229, 43, 80), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amaranth Deep Purple, whose RBG values are (171, 39, 79), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Amaranth Deep Purple, whose RBG values are (171, 39, 79), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amaranth Pink, whose RBG values are (241, 156, 187), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amaranthPinkColor;
/*!
* Returns a UIColor object representing the color Amaranth Pink, whose RBG values are (241, 156, 187), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amaranth Purple, whose RBG values are (171, 39, 79), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amaranthPurpleColor;
/*!
* Returns a UIColor object representing the color Amaranth Purple, whose RBG values are (171, 39, 79), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amaranth Red, whose RBG values are (211, 33, 45), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amaranthRedColor;
/*!
* Returns a UIColor object representing the color Amaranth Red, whose RBG values are (211, 33, 45), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amazon, whose RBG values are (59, 122, 87), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amazonColor;
/*!
* Returns a UIColor object representing the color Amazon, whose RBG values are (59, 122, 87), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amber, whose RBG values are (255, 191, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amberColor;
/*!
* Returns a UIColor object representing the color Amber, whose RBG values are (255, 191, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amberColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amber (SAE/ECE), whose RBG values are (255, 126, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amberSAEECEColor;
/*!
* Returns a UIColor object representing the color Amber (SAE/ECE), whose RBG values are (255, 126, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amber 100, whose RBG values are (255, 236, 179), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amber100Color;
/*!
* Returns a UIColor object representing the color Amber 100, whose RBG values are (255, 236, 179), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amber 200, whose RBG values are (255, 224, 130), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amber200Color;
/*!
* Returns a UIColor object representing the color Amber 200, whose RBG values are (255, 224, 130), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amber 300, whose RBG values are (255, 213, 79), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amber300Color;
/*!
* Returns a UIColor object representing the color Amber 300, whose RBG values are (255, 213, 79), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amber 400, whose RBG values are (255, 202, 40), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amber400Color;
/*!
* Returns a UIColor object representing the color Amber 400, whose RBG values are (255, 202, 40), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amber 50, whose RBG values are (255, 248, 225), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amber50Color;
/*!
* Returns a UIColor object representing the color Amber 50, whose RBG values are (255, 248, 225), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amber 500, whose RBG values are (255, 193, 7), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amber500Color;
/*!
* Returns a UIColor object representing the color Amber 500, whose RBG values are (255, 193, 7), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amber 600, whose RBG values are (255, 179, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amber600Color;
/*!
* Returns a UIColor object representing the color Amber 600, whose RBG values are (255, 179, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amber 700, whose RBG values are (255, 160, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amber700Color;
/*!
* Returns a UIColor object representing the color Amber 700, whose RBG values are (255, 160, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amber 800, whose RBG values are (255, 143, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amber800Color;
/*!
* Returns a UIColor object representing the color Amber 800, whose RBG values are (255, 143, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amber 900, whose RBG values are (255, 111, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amber900Color;
/*!
* Returns a UIColor object representing the color Amber 900, whose RBG values are (255, 111, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amber A100, whose RBG values are (255, 229, 127), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amberA100Color;
/*!
* Returns a UIColor object representing the color Amber A100, whose RBG values are (255, 229, 127), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amber A200, whose RBG values are (255, 215, 64), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amberA200Color;
/*!
* Returns a UIColor object representing the color Amber A200, whose RBG values are (255, 215, 64), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amber A400, whose RBG values are (255, 196, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amberA400Color;
/*!
* Returns a UIColor object representing the color Amber A400, whose RBG values are (255, 196, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amber A700, whose RBG values are (255, 171, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amberA700Color;
/*!
* Returns a UIColor object representing the color Amber A700, whose RBG values are (255, 171, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color American Rose, whose RBG values are (255, 3, 62), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) americanRoseColor;
/*!
* Returns a UIColor object representing the color American Rose, whose RBG values are (255, 3, 62), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Amethyst, whose RBG values are (153, 102, 204), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) amethystColor;
/*!
* Returns a UIColor object representing the color Amethyst, whose RBG values are (153, 102, 204), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Android Green, whose RBG values are (164, 198, 57), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) androidGreenColor;
/*!
* Returns a UIColor object representing the color Android Green, whose RBG values are (164, 198, 57), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Anti-Flash White, whose RBG values are (242, 243, 244), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) antiFlashWhiteColor;
/*!
* Returns a UIColor object representing the color Anti-Flash White, whose RBG values are (242, 243, 244), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Antique Brass (Crayola), whose RBG values are (205, 149, 117), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Antique Brass (Crayola), whose RBG values are (205, 149, 117), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Antique Bronze, whose RBG values are (102, 93, 30), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) antiqueBronzeColor;
/*!
* Returns a UIColor object representing the color Antique Bronze, whose RBG values are (102, 93, 30), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Antique Fuchsia, whose RBG values are (145, 92, 131), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) antiqueFuchsiaColor;
/*!
* Returns a UIColor object representing the color Antique Fuchsia, whose RBG values are (145, 92, 131), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Antique Ruby, whose RBG values are (132, 27, 45), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) antiqueRubyColor;
/*!
* Returns a UIColor object representing the color Antique Ruby, whose RBG values are (132, 27, 45), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Antique White, whose RBG values are (250, 235, 215), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) antiqueWhiteColor;
/*!
* Returns a UIColor object representing the color Antique White, whose RBG values are (250, 235, 215), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ao (English), whose RBG values are (0, 128, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) aoEnglishColor;
/*!
* Returns a UIColor object representing the color Ao (English), whose RBG values are (0, 128, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Apple Green, whose RBG values are (141, 182, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) appleGreenColor;
/*!
* Returns a UIColor object representing the color Apple Green, whose RBG values are (141, 182, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Apricot, whose RBG values are (251, 206, 177), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) apricotColor;
/*!
* Returns a UIColor object representing the color Apricot, whose RBG values are (251, 206, 177), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Apricot (Crayola), whose RBG values are (253, 217, 181), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) apricotCrayolaColor;
/*!
* Returns a UIColor object representing the color Apricot (Crayola), whose RBG values are (253, 217, 181), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Aqua, whose RBG values are (0, 255, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) aquaColor;
/*!
* Returns a UIColor object representing the color Aqua, whose RBG values are (0, 255, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) aquaColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Aquamarine, whose RBG values are (127, 255, 212), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) aquamarineColor;
/*!
* Returns a UIColor object representing the color Aquamarine, whose RBG values are (127, 255, 212), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Aquamarine (Crayola), whose RBG values are (120, 219, 226), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Aquamarine (Crayola), whose RBG values are (120, 219, 226), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Arctic Lime, whose RBG values are (208, 255, 20), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) arcticLimeColor;
/*!
* Returns a UIColor object representing the color Arctic Lime, whose RBG values are (208, 255, 20), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Army Green, whose RBG values are (75, 83, 32), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) armyGreenColor;
/*!
* Returns a UIColor object representing the color Army Green, whose RBG values are (75, 83, 32), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Arsenic, whose RBG values are (59, 68, 75), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) arsenicColor;
/*!
* Returns a UIColor object representing the color Arsenic, whose RBG values are (59, 68, 75), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Artichoke, whose RBG values are (143, 151, 121), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) artichokeColor;
/*!
* Returns a UIColor object representing the color Artichoke, whose RBG values are (143, 151, 121), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Arylide Yellow, whose RBG values are (233, 214, 107), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) arylideYellowColor;
/*!
* Returns a UIColor object representing the color Arylide Yellow, whose RBG values are (233, 214, 107), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ash Grey, whose RBG values are (178, 190, 181), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ashGreyColor;
/*!
* Returns a UIColor object representing the color Ash Grey, whose RBG values are (178, 190, 181), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Asparagus (Crayola), whose RBG values are (135, 169, 107), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Asparagus (Crayola), whose RBG values are (135, 169, 107), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Atomic Tangerine (Crayola), whose RBG values are (255, 164, 116), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Atomic Tangerine (Crayola), whose RBG values are (255, 164, 116), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Atomic Tangerine, whose RBG values are (255, 153, 102), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Atomic Tangerine, whose RBG values are (255, 153, 102), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Auburn, whose RBG values are (165, 42, 42), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) auburnColor;
/*!
* Returns a UIColor object representing the color Auburn, whose RBG values are (165, 42, 42), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Aureolin, whose RBG values are (253, 238, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) aureolinColor;
/*!
* Returns a UIColor object representing the color Aureolin, whose RBG values are (253, 238, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color AuroMetalSaurus, whose RBG values are (110, 127, 128), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color AuroMetalSaurus, whose RBG values are (110, 127, 128), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Avocado, whose RBG values are (86, 130, 3), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) avocadoColor;
/*!
* Returns a UIColor object representing the color Avocado, whose RBG values are (86, 130, 3), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Azure, whose RBG values are (0, 127, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) azureColor;
/*!
* Returns a UIColor object representing the color Azure, whose RBG values are (0, 127, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) azureColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Azure (Web Color), whose RBG values are (240, 255, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) azureWebColor;
/*!
* Returns a UIColor object representing the color Azure (Web Color), whose RBG values are (240, 255, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Azure Mist, whose RBG values are (240, 255, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) azureMistColor;
/*!
* Returns a UIColor object representing the color Azure Mist, whose RBG values are (240, 255, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Azureish White, whose RBG values are (219, 233, 244), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) azureishWhiteColor;
/*!
* Returns a UIColor object representing the color Azureish White, whose RBG values are (219, 233, 244), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color B'dazzled Blue, whose RBG values are (46, 88, 148), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) bdazzledBlueColor;
/*!
* Returns a UIColor object representing the color B'dazzled Blue, whose RBG values are (46, 88, 148), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Baby Blue, whose RBG values are (137, 207, 240), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) babyBlueColor;
/*!
* Returns a UIColor object representing the color Baby Blue, whose RBG values are (137, 207, 240), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Baby Blue Eyes, whose RBG values are (161, 202, 241), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) babyBlueEyesColor;
/*!
* Returns a UIColor object representing the color Baby Blue Eyes, whose RBG values are (161, 202, 241), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Baby Pink, whose RBG values are (244, 194, 194), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) babyPinkColor;
/*!
* Returns a UIColor object representing the color Baby Pink, whose RBG values are (244, 194, 194), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Baby Powder, whose RBG values are (254, 254, 250), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) babyPowderColor;
/*!
* Returns a UIColor object representing the color Baby Powder, whose RBG values are (254, 254, 250), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Baker-Miller Pink, whose RBG values are (255, 145, 175), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Baker-Miller Pink, whose RBG values are (255, 145, 175), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ball Blue, whose RBG values are (33, 171, 205), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ballBlueColor;
/*!
* Returns a UIColor object representing the color Ball Blue, whose RBG values are (33, 171, 205), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Banana Mania (Crayola), whose RBG values are (250, 231, 181), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Banana Mania (Crayola), whose RBG values are (250, 231, 181), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Banana Yellow, whose RBG values are (255, 225, 53), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) bananaYellowColor;
/*!
* Returns a UIColor object representing the color Banana Yellow, whose RBG values are (255, 225, 53), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bangladesh Green, whose RBG values are (0, 106, 78), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Bangladesh Green, whose RBG values are (0, 106, 78), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Barbie Pink, whose RBG values are (224, 33, 138), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) barbiePinkColor;
/*!
* Returns a UIColor object representing the color Barbie Pink, whose RBG values are (224, 33, 138), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Barn Red, whose RBG values are (124, 10, 2), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) barnRedColor;
/*!
* Returns a UIColor object representing the color Barn Red, whose RBG values are (124, 10, 2), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Battleship Grey, whose RBG values are (132, 132, 130), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) battleshipGreyColor;
/*!
* Returns a UIColor object representing the color Battleship Grey, whose RBG values are (132, 132, 130), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bazaar, whose RBG values are (152, 119, 123), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) bazaarColor;
/*!
* Returns a UIColor object representing the color Bazaar, whose RBG values are (152, 119, 123), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Beau Blue, whose RBG values are (188, 212, 230), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) beauBlueColor;
/*!
* Returns a UIColor object representing the color Beau Blue, whose RBG values are (188, 212, 230), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Beaver (Crayola), whose RBG values are (159, 129, 112), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) beaverCrayolaColor;
/*!
* Returns a UIColor object representing the color Beaver (Crayola), whose RBG values are (159, 129, 112), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Beige, whose RBG values are (245, 245, 220), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) beigeColor;
/*!
* Returns a UIColor object representing the color Beige, whose RBG values are (245, 245, 220), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) beigeColorWithAlpha:(CGFloat) alpha;
+ (UIColor *) bigDipOrubyColor;
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bisque, whose RBG values are (255, 228, 196), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) bisqueColor;
/*!
* Returns a UIColor object representing the color Bisque, whose RBG values are (255, 228, 196), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bistre, whose RBG values are (61, 43, 31), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) bistreColor;
/*!
* Returns a UIColor object representing the color Bistre, whose RBG values are (61, 43, 31), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bistre Brown, whose RBG values are (150, 113, 23), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) bistreBrownColor;
/*!
* Returns a UIColor object representing the color Bistre Brown, whose RBG values are (150, 113, 23), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bitter Lemon, whose RBG values are (202, 224, 13), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) bitterLemonColor;
/*!
* Returns a UIColor object representing the color Bitter Lemon, whose RBG values are (202, 224, 13), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bitter Lime, whose RBG values are (191, 255, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) bitterLimeColor;
/*!
* Returns a UIColor object representing the color Bitter Lime, whose RBG values are (191, 255, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bittersweet, whose RBG values are (254, 111, 94), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) bittersweetColor;
/*!
* Returns a UIColor object representing the color Bittersweet, whose RBG values are (254, 111, 94), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bittersweet (Crayola), whose RBG values are (253, 124, 110), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Bittersweet (Crayola), whose RBG values are (253, 124, 110), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bittersweet Shimmer, whose RBG values are (191, 79, 81), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Bittersweet Shimmer, whose RBG values are (191, 79, 81), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Black Bean, whose RBG values are (61, 12, 2), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blackBeanColor;
/*!
* Returns a UIColor object representing the color Black Bean, whose RBG values are (61, 12, 2), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Black Leather Jacket, whose RBG values are (37, 53, 41), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Black Leather Jacket, whose RBG values are (37, 53, 41), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Black Olive, whose RBG values are (59, 60, 54), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blackOliveColor;
/*!
* Returns a UIColor object representing the color Black Olive, whose RBG values are (59, 60, 54), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blanched Almond, whose RBG values are (255, 235, 205), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blanchedAlmondColor;
/*!
* Returns a UIColor object representing the color Blanched Almond, whose RBG values are (255, 235, 205), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blast-Off Bronze, whose RBG values are (165, 113, 100), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blastOffBronzeColor;
/*!
* Returns a UIColor object representing the color Blast-Off Bronze, whose RBG values are (165, 113, 100), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bleu De France, whose RBG values are (49, 140, 231), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) bleuDeFranceColor;
/*!
* Returns a UIColor object representing the color Bleu De France, whose RBG values are (49, 140, 231), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blizzard Blue (Crayola), whose RBG values are (172, 229, 238), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Blizzard Blue (Crayola), whose RBG values are (172, 229, 238), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blond, whose RBG values are (250, 240, 190), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blondColor;
/*!
* Returns a UIColor object representing the color Blond, whose RBG values are (250, 240, 190), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blondColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue (Crayola), whose RBG values are (31, 117, 254), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueCrayolaColor;
/*!
* Returns a UIColor object representing the color Blue (Crayola), whose RBG values are (31, 117, 254), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue (Munsell), whose RBG values are (0, 147, 175), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueMunsellColor;
/*!
* Returns a UIColor object representing the color Blue (Munsell), whose RBG values are (0, 147, 175), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue (NCS), whose RBG values are (0, 135, 189), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueNCSColor;
/*!
* Returns a UIColor object representing the color Blue (NCS), whose RBG values are (0, 135, 189), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue (Pantone), whose RBG values are (0, 24, 168), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) bluePantoneColor;
/*!
* Returns a UIColor object representing the color Blue (Pantone), whose RBG values are (0, 24, 168), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue (Pigment), whose RBG values are (51, 51, 153), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) bluePigmentColor;
/*!
* Returns a UIColor object representing the color Blue (Pigment), whose RBG values are (51, 51, 153), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue (RYB), whose RBG values are (2, 71, 254), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueRYBColor;
/*!
* Returns a UIColor object representing the color Blue (RYB), whose RBG values are (2, 71, 254), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue 100, whose RBG values are (187, 222, 251), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blue100Color;
/*!
* Returns a UIColor object representing the color Blue 100, whose RBG values are (187, 222, 251), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue 200, whose RBG values are (144, 202, 249), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blue200Color;
/*!
* Returns a UIColor object representing the color Blue 200, whose RBG values are (144, 202, 249), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue 300, whose RBG values are (100, 181, 246), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blue300Color;
/*!
* Returns a UIColor object representing the color Blue 300, whose RBG values are (100, 181, 246), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue 400, whose RBG values are (66, 165, 245), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blue400Color;
/*!
* Returns a UIColor object representing the color Blue 400, whose RBG values are (66, 165, 245), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue 50, whose RBG values are (227, 242, 253), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blue50Color;
/*!
* Returns a UIColor object representing the color Blue 50, whose RBG values are (227, 242, 253), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue 500, whose RBG values are (33, 150, 243), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blue500Color;
/*!
* Returns a UIColor object representing the color Blue 500, whose RBG values are (33, 150, 243), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue 600, whose RBG values are (30, 136, 229), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blue600Color;
/*!
* Returns a UIColor object representing the color Blue 600, whose RBG values are (30, 136, 229), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue 700, whose RBG values are (25, 118, 210), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blue700Color;
/*!
* Returns a UIColor object representing the color Blue 700, whose RBG values are (25, 118, 210), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue 800, whose RBG values are (21, 101, 192), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blue800Color;
/*!
* Returns a UIColor object representing the color Blue 800, whose RBG values are (21, 101, 192), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue 900, whose RBG values are (13, 71, 161), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blue900Color;
/*!
* Returns a UIColor object representing the color Blue 900, whose RBG values are (13, 71, 161), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue A100, whose RBG values are (130, 177, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueA100Color;
/*!
* Returns a UIColor object representing the color Blue A100, whose RBG values are (130, 177, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue A200, whose RBG values are (68, 138, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueA200Color;
/*!
* Returns a UIColor object representing the color Blue A200, whose RBG values are (68, 138, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue A400, whose RBG values are (41, 121, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueA400Color;
/*!
* Returns a UIColor object representing the color Blue A400, whose RBG values are (41, 121, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue A700, whose RBG values are (41, 98, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueA700Color;
/*!
* Returns a UIColor object representing the color Blue A700, whose RBG values are (41, 98, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue Bell (Crayola), whose RBG values are (162, 162, 208), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Blue Bell (Crayola), whose RBG values are (162, 162, 208), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue Green (Crayola), whose RBG values are (13, 152, 186), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Blue Green (Crayola), whose RBG values are (13, 152, 186), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue Grey 100, whose RBG values are (207, 216, 220), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueGrey100Color;
/*!
* Returns a UIColor object representing the color Blue Grey 100, whose RBG values are (207, 216, 220), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue Grey 200, whose RBG values are (176, 190, 197), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueGrey200Color;
/*!
* Returns a UIColor object representing the color Blue Grey 200, whose RBG values are (176, 190, 197), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue Grey 300, whose RBG values are (144, 164, 174), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueGrey300Color;
/*!
* Returns a UIColor object representing the color Blue Grey 300, whose RBG values are (144, 164, 174), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue Grey 400, whose RBG values are (120, 144, 156), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueGrey400Color;
/*!
* Returns a UIColor object representing the color Blue Grey 400, whose RBG values are (120, 144, 156), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue Grey 50, whose RBG values are (236, 239, 241), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueGrey50Color;
/*!
* Returns a UIColor object representing the color Blue Grey 50, whose RBG values are (236, 239, 241), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue Grey 500, whose RBG values are (96, 125, 139), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueGrey500Color;
/*!
* Returns a UIColor object representing the color Blue Grey 500, whose RBG values are (96, 125, 139), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue Grey 600, whose RBG values are (84, 110, 122), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueGrey600Color;
/*!
* Returns a UIColor object representing the color Blue Grey 600, whose RBG values are (84, 110, 122), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue Grey 700, whose RBG values are (69, 90, 100), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueGrey700Color;
/*!
* Returns a UIColor object representing the color Blue Grey 700, whose RBG values are (69, 90, 100), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue Grey 800, whose RBG values are (55, 71, 79), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueGrey800Color;
/*!
* Returns a UIColor object representing the color Blue Grey 800, whose RBG values are (55, 71, 79), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue Grey 900, whose RBG values are (38, 50, 56), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueGrey900Color;
/*!
* Returns a UIColor object representing the color Blue Grey 900, whose RBG values are (38, 50, 56), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue Lagoon, whose RBG values are (94, 147, 161), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueLagoonColor;
/*!
* Returns a UIColor object representing the color Blue Lagoon, whose RBG values are (94, 147, 161), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue Violet (Crayola), whose RBG values are (115, 102, 189), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Blue Violet (Crayola), whose RBG values are (115, 102, 189), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue Sapphire, whose RBG values are (18, 97, 128), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueSapphireColor;
/*!
* Returns a UIColor object representing the color Blue Sapphire, whose RBG values are (18, 97, 128), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue Yonder, whose RBG values are (80, 114, 167), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueYonderColor;
/*!
* Returns a UIColor object representing the color Blue Yonder, whose RBG values are (80, 114, 167), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue-Gray, whose RBG values are (102, 153, 204), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueGrayColor;
/*!
* Returns a UIColor object representing the color Blue-Gray, whose RBG values are (102, 153, 204), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue-Magenta Violet, whose RBG values are (85, 53, 146), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Blue-Magenta Violet, whose RBG values are (85, 53, 146), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blue-Violet, whose RBG values are (138, 43, 226), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueVioletColor;
/*!
* Returns a UIColor object representing the color Blue-Violet, whose RBG values are (138, 43, 226), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blueberry, whose RBG values are (79, 134, 247), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blueberryColor;
/*!
* Returns a UIColor object representing the color Blueberry, whose RBG values are (79, 134, 247), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bluebonnet, whose RBG values are (28, 28, 240), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) bluebonnetColor;
/*!
* Returns a UIColor object representing the color Bluebonnet, whose RBG values are (28, 28, 240), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Blush (Crayola), whose RBG values are (222, 93, 131), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) blushCrayolaColor;
/*!
* Returns a UIColor object representing the color Blush (Crayola), whose RBG values are (222, 93, 131), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bole, whose RBG values are (121, 68, 59), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) boleColor;
/*!
* Returns a UIColor object representing the color Bole, whose RBG values are (121, 68, 59), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) boleColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bondi Blue, whose RBG values are (0, 149, 182), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) bondiBlueColor;
/*!
* Returns a UIColor object representing the color Bondi Blue, whose RBG values are (0, 149, 182), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bone, whose RBG values are (227, 218, 201), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) boneColor;
/*!
* Returns a UIColor object representing the color Bone, whose RBG values are (227, 218, 201), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) boneColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Boston University Red, whose RBG values are (204, 0, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Boston University Red, whose RBG values are (204, 0, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bottle Green, whose RBG values are (0, 106, 78), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) bottleGreenColor;
/*!
* Returns a UIColor object representing the color Bottle Green, whose RBG values are (0, 106, 78), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Boysenberry, whose RBG values are (135, 50, 96), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) boysenberryColor;
/*!
* Returns a UIColor object representing the color Boysenberry, whose RBG values are (135, 50, 96), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brandeis Blue, whose RBG values are (0, 112, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brandeisBlueColor;
/*!
* Returns a UIColor object representing the color Brandeis Blue, whose RBG values are (0, 112, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brass, whose RBG values are (181, 166, 66), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brassColor;
/*!
* Returns a UIColor object representing the color Brass, whose RBG values are (181, 166, 66), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brassColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brick Red (Crayola), whose RBG values are (203, 65, 84), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Brick Red (Crayola), whose RBG values are (203, 65, 84), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bright Cerulean, whose RBG values are (29, 172, 214), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brightCeruleanColor;
/*!
* Returns a UIColor object representing the color Bright Cerulean, whose RBG values are (29, 172, 214), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bright Green, whose RBG values are (102, 255, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brightGreenColor;
/*!
* Returns a UIColor object representing the color Bright Green, whose RBG values are (102, 255, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bright Lavender, whose RBG values are (191, 148, 228), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brightLavenderColor;
/*!
* Returns a UIColor object representing the color Bright Lavender, whose RBG values are (191, 148, 228), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bright Lilac, whose RBG values are (216, 145, 239), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brightLilacColor;
/*!
* Returns a UIColor object representing the color Bright Lilac, whose RBG values are (216, 145, 239), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bright Maroon, whose RBG values are (195, 33, 72), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brightMaroonColor;
/*!
* Returns a UIColor object representing the color Bright Maroon, whose RBG values are (195, 33, 72), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bright Navy Blue, whose RBG values are (25, 116, 210), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brightNavyBlueColor;
/*!
* Returns a UIColor object representing the color Bright Navy Blue, whose RBG values are (25, 116, 210), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bright Pink, whose RBG values are (255, 0, 127), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brightPinkColor;
/*!
* Returns a UIColor object representing the color Bright Pink, whose RBG values are (255, 0, 127), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bright Turquoise, whose RBG values are (8, 232, 222), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Bright Turquoise, whose RBG values are (8, 232, 222), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bright Ube, whose RBG values are (209, 159, 232), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brightUbeColor;
/*!
* Returns a UIColor object representing the color Bright Ube, whose RBG values are (209, 159, 232), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brilliant Rose (Crayola), whose RBG values are (255, 85, 163), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Brilliant Rose (Crayola), whose RBG values are (255, 85, 163), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brilliant Azure, whose RBG values are (51, 153, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brilliantAzureColor;
/*!
* Returns a UIColor object representing the color Brilliant Azure, whose RBG values are (51, 153, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brilliant Lavender, whose RBG values are (244, 187, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Brilliant Lavender, whose RBG values are (244, 187, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brilliant Rose, whose RBG values are (246, 83, 166), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brilliantRoseColor;
/*!
* Returns a UIColor object representing the color Brilliant Rose, whose RBG values are (246, 83, 166), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brink Pink, whose RBG values are (251, 96, 127), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brinkPinkColor;
/*!
* Returns a UIColor object representing the color Brink Pink, whose RBG values are (251, 96, 127), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color British Racing Green, whose RBG values are (0, 66, 37), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color British Racing Green, whose RBG values are (0, 66, 37), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bronze, whose RBG values are (205, 127, 50), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) bronzeColor;
/*!
* Returns a UIColor object representing the color Bronze, whose RBG values are (205, 127, 50), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bronze Yellow, whose RBG values are (115, 112, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) bronzeYellowColor;
/*!
* Returns a UIColor object representing the color Bronze Yellow, whose RBG values are (115, 112, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brown (Crayola), whose RBG values are (180, 103, 77), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brownCrayolaColor;
/*!
* Returns a UIColor object representing the color Brown (Crayola), whose RBG values are (180, 103, 77), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brown (Traditional), whose RBG values are (150, 75, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Brown (Traditional), whose RBG values are (150, 75, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brown (Web), whose RBG values are (165, 42, 42), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brownWebColor;
/*!
* Returns a UIColor object representing the color Brown (Web), whose RBG values are (165, 42, 42), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brown 100, whose RBG values are (215, 204, 200), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brown100Color;
/*!
* Returns a UIColor object representing the color Brown 100, whose RBG values are (215, 204, 200), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brown 200, whose RBG values are (188, 170, 164), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brown200Color;
/*!
* Returns a UIColor object representing the color Brown 200, whose RBG values are (188, 170, 164), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brown 300, whose RBG values are (161, 136, 127), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brown300Color;
/*!
* Returns a UIColor object representing the color Brown 300, whose RBG values are (161, 136, 127), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brown 400, whose RBG values are (141, 110, 99), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brown400Color;
/*!
* Returns a UIColor object representing the color Brown 400, whose RBG values are (141, 110, 99), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brown 50, whose RBG values are (239, 235, 233), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brown50Color;
/*!
* Returns a UIColor object representing the color Brown 50, whose RBG values are (239, 235, 233), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brown 500, whose RBG values are (121, 85, 72), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brown500Color;
/*!
* Returns a UIColor object representing the color Brown 500, whose RBG values are (121, 85, 72), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brown 600, whose RBG values are (109, 76, 65), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brown600Color;
/*!
* Returns a UIColor object representing the color Brown 600, whose RBG values are (109, 76, 65), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brown 700, whose RBG values are (93, 64, 55), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brown700Color;
/*!
* Returns a UIColor object representing the color Brown 700, whose RBG values are (93, 64, 55), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brown 800, whose RBG values are (78, 52, 46), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brown800Color;
/*!
* Returns a UIColor object representing the color Brown 800, whose RBG values are (78, 52, 46), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brown 900, whose RBG values are (62, 39, 35), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brown900Color;
/*!
* Returns a UIColor object representing the color Brown 900, whose RBG values are (62, 39, 35), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brown Yellow, whose RBG values are (204, 153, 102), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brownYellowColor;
/*!
* Returns a UIColor object representing the color Brown Yellow, whose RBG values are (204, 153, 102), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brown-Nose, whose RBG values are (107, 68, 35), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brownNoseColor;
/*!
* Returns a UIColor object representing the color Brown-Nose, whose RBG values are (107, 68, 35), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Brunswick Green, whose RBG values are (27, 77, 62), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) brunswickGreenColor;
/*!
* Returns a UIColor object representing the color Brunswick Green, whose RBG values are (27, 77, 62), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bubble Gum, whose RBG values are (255, 193, 204), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) bubbleGumColor;
/*!
* Returns a UIColor object representing the color Bubble Gum, whose RBG values are (255, 193, 204), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bubbles, whose RBG values are (231, 254, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) bubblesColor;
/*!
* Returns a UIColor object representing the color Bubbles, whose RBG values are (231, 254, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bud Green, whose RBG values are (123, 182, 97), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) budGreenColor;
/*!
* Returns a UIColor object representing the color Bud Green, whose RBG values are (123, 182, 97), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Buff, whose RBG values are (240, 220, 130), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) buffColor;
/*!
* Returns a UIColor object representing the color Buff, whose RBG values are (240, 220, 130), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) buffColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Bulgarian Rose, whose RBG values are (72, 6, 7), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) bulgarianRoseColor;
/*!
* Returns a UIColor object representing the color Bulgarian Rose, whose RBG values are (72, 6, 7), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Burgundy, whose RBG values are (128, 0, 32), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) burgundyColor;
/*!
* Returns a UIColor object representing the color Burgundy, whose RBG values are (128, 0, 32), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Burlywood, whose RBG values are (222, 184, 135), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) burlywoodColor;
/*!
* Returns a UIColor object representing the color Burlywood, whose RBG values are (222, 184, 135), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Burnt Orange (Crayola), whose RBG values are (255, 127, 73), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Burnt Orange (Crayola), whose RBG values are (255, 127, 73), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Burnt Sienna (Crayola), whose RBG values are (234, 126, 93), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Burnt Sienna (Crayola), whose RBG values are (234, 126, 93), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Burnt Orange, whose RBG values are (204, 85, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) burntOrangeColor;
/*!
* Returns a UIColor object representing the color Burnt Orange, whose RBG values are (204, 85, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Burnt Sienna, whose RBG values are (233, 116, 81), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) burntSiennaColor;
/*!
* Returns a UIColor object representing the color Burnt Sienna, whose RBG values are (233, 116, 81), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Burnt Umber, whose RBG values are (138, 51, 36), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) burntUmberColor;
/*!
* Returns a UIColor object representing the color Burnt Umber, whose RBG values are (138, 51, 36), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Byzantine, whose RBG values are (189, 51, 164), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) byzantineColor;
/*!
* Returns a UIColor object representing the color Byzantine, whose RBG values are (189, 51, 164), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Byzantium, whose RBG values are (112, 41, 99), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) byzantiumColor;
/*!
* Returns a UIColor object representing the color Byzantium, whose RBG values are (112, 41, 99), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color CG Blue, whose RBG values are (0, 122, 165), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cGBlueColor;
/*!
* Returns a UIColor object representing the color CG Blue, whose RBG values are (0, 122, 165), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color CG Red, whose RBG values are (224, 60, 49), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cGRedColor;
/*!
* Returns a UIColor object representing the color CG Red, whose RBG values are (224, 60, 49), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cGRedColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cadet, whose RBG values are (83, 104, 114), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cadetColor;
/*!
* Returns a UIColor object representing the color Cadet, whose RBG values are (83, 104, 114), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cadetColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cadet Blue (Crayola), whose RBG values are (176, 183, 198), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Cadet Blue (Crayola), whose RBG values are (176, 183, 198), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cadet Blue, whose RBG values are (95, 158, 160), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cadetBlueColor;
/*!
* Returns a UIColor object representing the color Cadet Blue, whose RBG values are (95, 158, 160), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cadet Grey, whose RBG values are (145, 163, 176), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cadetGreyColor;
/*!
* Returns a UIColor object representing the color Cadet Grey, whose RBG values are (145, 163, 176), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cadmium Green, whose RBG values are (0, 107, 60), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cadmiumGreenColor;
/*!
* Returns a UIColor object representing the color Cadmium Green, whose RBG values are (0, 107, 60), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cadmium Orange, whose RBG values are (237, 135, 45), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cadmiumOrangeColor;
/*!
* Returns a UIColor object representing the color Cadmium Orange, whose RBG values are (237, 135, 45), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cadmium Red, whose RBG values are (227, 0, 34), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cadmiumRedColor;
/*!
* Returns a UIColor object representing the color Cadmium Red, whose RBG values are (227, 0, 34), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cadmium Yellow, whose RBG values are (255, 246, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cadmiumYellowColor;
/*!
* Returns a UIColor object representing the color Cadmium Yellow, whose RBG values are (255, 246, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
+ (UIColor *) caféAuLaitColor;
+ (UIColor *) caféAuLaitColorWithAlpha:(CGFloat) alpha;
+ (UIColor *) caféNoirColor;
+ (UIColor *) caféNoirColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cal Poly Green, whose RBG values are (30, 77, 43), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) calPolyGreenColor;
/*!
* Returns a UIColor object representing the color Cal Poly Green, whose RBG values are (30, 77, 43), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cambridge Blue, whose RBG values are (163, 193, 173), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cambridgeBlueColor;
/*!
* Returns a UIColor object representing the color Cambridge Blue, whose RBG values are (163, 193, 173), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Camel, whose RBG values are (193, 154, 107), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) camelColor;
/*!
* Returns a UIColor object representing the color Camel, whose RBG values are (193, 154, 107), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) camelColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cameo Pink, whose RBG values are (239, 187, 204), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cameoPinkColor;
/*!
* Returns a UIColor object representing the color Cameo Pink, whose RBG values are (239, 187, 204), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Camouflage Green, whose RBG values are (120, 134, 107), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Camouflage Green, whose RBG values are (120, 134, 107), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Canary (Crayola), whose RBG values are (255, 255, 153), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) canaryCrayolaColor;
/*!
* Returns a UIColor object representing the color Canary (Crayola), whose RBG values are (255, 255, 153), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Canary Yellow, whose RBG values are (255, 239, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) canaryYellowColor;
/*!
* Returns a UIColor object representing the color Canary Yellow, whose RBG values are (255, 239, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Candy Apple Red, whose RBG values are (255, 8, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) candyAppleRedColor;
/*!
* Returns a UIColor object representing the color Candy Apple Red, whose RBG values are (255, 8, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Candy Pink, whose RBG values are (228, 113, 122), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) candyPinkColor;
/*!
* Returns a UIColor object representing the color Candy Pink, whose RBG values are (228, 113, 122), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Capri, whose RBG values are (0, 191, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) capriColor;
/*!
* Returns a UIColor object representing the color Capri, whose RBG values are (0, 191, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) capriColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Caput Mortuum, whose RBG values are (89, 39, 32), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) caputMortuumColor;
/*!
* Returns a UIColor object representing the color Caput Mortuum, whose RBG values are (89, 39, 32), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cardinal, whose RBG values are (196, 30, 58), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cardinalColor;
/*!
* Returns a UIColor object representing the color Cardinal, whose RBG values are (196, 30, 58), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Caribbean Green (Crayola), whose RBG values are (0, 204, 153), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Caribbean Green (Crayola), whose RBG values are (0, 204, 153), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Carmine, whose RBG values are (150, 0, 24), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) carmineColor;
/*!
* Returns a UIColor object representing the color Carmine, whose RBG values are (150, 0, 24), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Carmine (M&P), whose RBG values are (215, 0, 64), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) carmineMandPColor;
/*!
* Returns a UIColor object representing the color Carmine (M&P), whose RBG values are (215, 0, 64), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Carmine Pink, whose RBG values are (235, 76, 66), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) carminePinkColor;
/*!
* Returns a UIColor object representing the color Carmine Pink, whose RBG values are (235, 76, 66), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Carmine Red, whose RBG values are (255, 0, 56), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) carmineRedColor;
/*!
* Returns a UIColor object representing the color Carmine Red, whose RBG values are (255, 0, 56), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Carnation Pink (Crayola), whose RBG values are (255, 170, 204), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Carnation Pink (Crayola), whose RBG values are (255, 170, 204), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Carnation Pink, whose RBG values are (255, 166, 201), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) carnationPinkColor;
/*!
* Returns a UIColor object representing the color Carnation Pink, whose RBG values are (255, 166, 201), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Carnelian, whose RBG values are (179, 27, 27), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) carnelianColor;
/*!
* Returns a UIColor object representing the color Carnelian, whose RBG values are (179, 27, 27), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Carolina Blue, whose RBG values are (86, 160, 211), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) carolinaBlueColor;
/*!
* Returns a UIColor object representing the color Carolina Blue, whose RBG values are (86, 160, 211), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Carrot Orange, whose RBG values are (237, 145, 33), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) carrotOrangeColor;
/*!
* Returns a UIColor object representing the color Carrot Orange, whose RBG values are (237, 145, 33), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Castleton Green, whose RBG values are (0, 86, 63), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) castletonGreenColor;
/*!
* Returns a UIColor object representing the color Castleton Green, whose RBG values are (0, 86, 63), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Catalina Blue, whose RBG values are (6, 42, 120), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) catalinaBlueColor;
/*!
* Returns a UIColor object representing the color Catalina Blue, whose RBG values are (6, 42, 120), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Catawba, whose RBG values are (112, 54, 66), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) catawbaColor;
/*!
* Returns a UIColor object representing the color Catawba, whose RBG values are (112, 54, 66), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cedar Chest, whose RBG values are (201, 90, 73), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cedarChestColor;
/*!
* Returns a UIColor object representing the color Cedar Chest, whose RBG values are (201, 90, 73), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ceil, whose RBG values are (146, 161, 207), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ceilColor;
/*!
* Returns a UIColor object representing the color Ceil, whose RBG values are (146, 161, 207), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ceilColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Celadon, whose RBG values are (172, 225, 175), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) celadonColor;
/*!
* Returns a UIColor object representing the color Celadon, whose RBG values are (172, 225, 175), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Celadon Blue, whose RBG values are (0, 123, 167), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) celadonBlueColor;
/*!
* Returns a UIColor object representing the color Celadon Blue, whose RBG values are (0, 123, 167), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Celadon Green, whose RBG values are (47, 132, 124), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) celadonGreenColor;
/*!
* Returns a UIColor object representing the color Celadon Green, whose RBG values are (47, 132, 124), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Celeste, whose RBG values are (178, 255, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) celesteColor;
/*!
* Returns a UIColor object representing the color Celeste, whose RBG values are (178, 255, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Celeste Opaco, whose RBG values are (128, 204, 204), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) celesteOpacoColor;
/*!
* Returns a UIColor object representing the color Celeste Opaco, whose RBG values are (128, 204, 204), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Celeste Pallido, whose RBG values are (204, 255, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) celestePallidoColor;
/*!
* Returns a UIColor object representing the color Celeste Pallido, whose RBG values are (204, 255, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Celeste Polvere, whose RBG values are (230, 255, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) celestePolvereColor;
/*!
* Returns a UIColor object representing the color Celeste Polvere, whose RBG values are (230, 255, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Celeste Velato, whose RBG values are (204, 230, 230), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) celesteVelatoColor;
/*!
* Returns a UIColor object representing the color Celeste Velato, whose RBG values are (204, 230, 230), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Celestial Blue, whose RBG values are (73, 151, 208), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) celestialBlueColor;
/*!
* Returns a UIColor object representing the color Celestial Blue, whose RBG values are (73, 151, 208), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cerise, whose RBG values are (222, 49, 99), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ceriseColor;
/*!
* Returns a UIColor object representing the color Cerise, whose RBG values are (222, 49, 99), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cerise (Crayola), whose RBG values are (221, 68, 146), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ceriseCrayolaColor;
/*!
* Returns a UIColor object representing the color Cerise (Crayola), whose RBG values are (221, 68, 146), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cerise Pink, whose RBG values are (236, 59, 131), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cerisePinkColor;
/*!
* Returns a UIColor object representing the color Cerise Pink, whose RBG values are (236, 59, 131), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cerulean, whose RBG values are (0, 123, 167), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ceruleanColor;
/*!
* Returns a UIColor object representing the color Cerulean, whose RBG values are (0, 123, 167), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cerulean (Crayola), whose RBG values are (29, 172, 214), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Cerulean (Crayola), whose RBG values are (29, 172, 214), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cerulean Blue, whose RBG values are (42, 82, 190), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ceruleanBlueColor;
/*!
* Returns a UIColor object representing the color Cerulean Blue, whose RBG values are (42, 82, 190), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cerulean Frost, whose RBG values are (109, 155, 195), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ceruleanFrostColor;
/*!
* Returns a UIColor object representing the color Cerulean Frost, whose RBG values are (109, 155, 195), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Chamoisee, whose RBG values are (160, 120, 90), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) chamoiseeColor;
/*!
* Returns a UIColor object representing the color Chamoisee, whose RBG values are (160, 120, 90), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Champagne, whose RBG values are (247, 231, 206), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) champagneColor;
/*!
* Returns a UIColor object representing the color Champagne, whose RBG values are (247, 231, 206), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Charcoal, whose RBG values are (54, 69, 79), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) charcoalColor;
/*!
* Returns a UIColor object representing the color Charcoal, whose RBG values are (54, 69, 79), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Charleston Green, whose RBG values are (35, 43, 43), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Charleston Green, whose RBG values are (35, 43, 43), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Charm Pink, whose RBG values are (230, 143, 172), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) charmPinkColor;
/*!
* Returns a UIColor object representing the color Charm Pink, whose RBG values are (230, 143, 172), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Chartreuse (Traditional), whose RBG values are (223, 255, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Chartreuse (Traditional), whose RBG values are (223, 255, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Chartreuse (Web), whose RBG values are (127, 255, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) chartreuseWebColor;
/*!
* Returns a UIColor object representing the color Chartreuse (Web), whose RBG values are (127, 255, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cherry, whose RBG values are (222, 49, 99), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cherryColor;
/*!
* Returns a UIColor object representing the color Cherry, whose RBG values are (222, 49, 99), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cherry Blossom Pink, whose RBG values are (255, 183, 197), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Cherry Blossom Pink, whose RBG values are (255, 183, 197), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Chestnut, whose RBG values are (149, 69, 53), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) chestnutColor;
/*!
* Returns a UIColor object representing the color Chestnut, whose RBG values are (149, 69, 53), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Chestnut (Crayola), whose RBG values are (188, 93, 88), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Chestnut (Crayola), whose RBG values are (188, 93, 88), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color China Pink, whose RBG values are (222, 111, 161), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) chinaPinkColor;
/*!
* Returns a UIColor object representing the color China Pink, whose RBG values are (222, 111, 161), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color China Rose, whose RBG values are (168, 81, 110), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) chinaRoseColor;
/*!
* Returns a UIColor object representing the color China Rose, whose RBG values are (168, 81, 110), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Chinese Red, whose RBG values are (170, 56, 30), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) chineseRedColor;
/*!
* Returns a UIColor object representing the color Chinese Red, whose RBG values are (170, 56, 30), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Chinese Violet, whose RBG values are (133, 96, 136), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) chineseVioletColor;
/*!
* Returns a UIColor object representing the color Chinese Violet, whose RBG values are (133, 96, 136), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Chocolate (Traditional), whose RBG values are (123, 63, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Chocolate (Traditional), whose RBG values are (123, 63, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Chocolate (Web), whose RBG values are (210, 105, 30), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) chocolateWebColor;
/*!
* Returns a UIColor object representing the color Chocolate (Web), whose RBG values are (210, 105, 30), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Chrome Yellow, whose RBG values are (255, 167, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) chromeYellowColor;
/*!
* Returns a UIColor object representing the color Chrome Yellow, whose RBG values are (255, 167, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cinereous, whose RBG values are (152, 129, 123), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cinereousColor;
/*!
* Returns a UIColor object representing the color Cinereous, whose RBG values are (152, 129, 123), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cinnabar, whose RBG values are (227, 66, 52), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cinnabarColor;
/*!
* Returns a UIColor object representing the color Cinnabar, whose RBG values are (227, 66, 52), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cinnamon, whose RBG values are (210, 105, 30), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cinnamonColor;
/*!
* Returns a UIColor object representing the color Cinnamon, whose RBG values are (210, 105, 30), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Citrine, whose RBG values are (228, 208, 10), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) citrineColor;
/*!
* Returns a UIColor object representing the color Citrine, whose RBG values are (228, 208, 10), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Citron, whose RBG values are (158, 169, 31), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) citronColor;
/*!
* Returns a UIColor object representing the color Citron, whose RBG values are (158, 169, 31), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Claret, whose RBG values are (127, 23, 52), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) claretColor;
/*!
* Returns a UIColor object representing the color Claret, whose RBG values are (127, 23, 52), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Classic Rose, whose RBG values are (251, 204, 231), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) classicRoseColor;
/*!
* Returns a UIColor object representing the color Classic Rose, whose RBG values are (251, 204, 231), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cobalt Blue, whose RBG values are (0, 71, 171), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cobaltBlueColor;
/*!
* Returns a UIColor object representing the color Cobalt Blue, whose RBG values are (0, 71, 171), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cocoa Brown, whose RBG values are (210, 105, 30), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cocoaBrownColor;
/*!
* Returns a UIColor object representing the color Cocoa Brown, whose RBG values are (210, 105, 30), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Coconut, whose RBG values are (150, 90, 62), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) coconutColor;
/*!
* Returns a UIColor object representing the color Coconut, whose RBG values are (150, 90, 62), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Coffee, whose RBG values are (111, 78, 55), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) coffeeColor;
/*!
* Returns a UIColor object representing the color Coffee, whose RBG values are (111, 78, 55), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Columbia Blue, whose RBG values are (196, 216, 226), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) columbiaBlueColor;
/*!
* Returns a UIColor object representing the color Columbia Blue, whose RBG values are (196, 216, 226), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Congo Pink, whose RBG values are (248, 131, 121), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) congoPinkColor;
/*!
* Returns a UIColor object representing the color Congo Pink, whose RBG values are (248, 131, 121), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cool Black, whose RBG values are (0, 46, 99), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) coolBlackColor;
/*!
* Returns a UIColor object representing the color Cool Black, whose RBG values are (0, 46, 99), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cool Grey, whose RBG values are (140, 146, 172), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) coolGreyColor;
/*!
* Returns a UIColor object representing the color Cool Grey, whose RBG values are (140, 146, 172), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Copper, whose RBG values are (184, 115, 51), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) copperColor;
/*!
* Returns a UIColor object representing the color Copper, whose RBG values are (184, 115, 51), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Copper (Crayola Alternate), whose RBG values are (221, 148, 117), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Copper (Crayola Alternate), whose RBG values are (221, 148, 117), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Copper (Crayola), whose RBG values are (218, 138, 103), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) copperCrayolaColor;
/*!
* Returns a UIColor object representing the color Copper (Crayola), whose RBG values are (218, 138, 103), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Copper Penny, whose RBG values are (173, 111, 105), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) copperPennyColor;
/*!
* Returns a UIColor object representing the color Copper Penny, whose RBG values are (173, 111, 105), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Copper Red, whose RBG values are (203, 109, 81), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) copperRedColor;
/*!
* Returns a UIColor object representing the color Copper Red, whose RBG values are (203, 109, 81), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Copper Rose, whose RBG values are (153, 102, 102), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) copperRoseColor;
/*!
* Returns a UIColor object representing the color Copper Rose, whose RBG values are (153, 102, 102), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Coquelicot, whose RBG values are (255, 56, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) coquelicotColor;
/*!
* Returns a UIColor object representing the color Coquelicot, whose RBG values are (255, 56, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Coral, whose RBG values are (255, 127, 80), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) coralColor;
/*!
* Returns a UIColor object representing the color Coral, whose RBG values are (255, 127, 80), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) coralColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Coral Pink, whose RBG values are (248, 131, 121), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) coralPinkColor;
/*!
* Returns a UIColor object representing the color Coral Pink, whose RBG values are (248, 131, 121), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Coral Red, whose RBG values are (255, 64, 64), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) coralRedColor;
/*!
* Returns a UIColor object representing the color Coral Red, whose RBG values are (255, 64, 64), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cordovan, whose RBG values are (137, 63, 69), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cordovanColor;
/*!
* Returns a UIColor object representing the color Cordovan, whose RBG values are (137, 63, 69), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Corn, whose RBG values are (251, 236, 93), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cornColor;
/*!
* Returns a UIColor object representing the color Corn, whose RBG values are (251, 236, 93), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cornColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cornell Red, whose RBG values are (179, 27, 27), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cornellRedColor;
/*!
* Returns a UIColor object representing the color Cornell Red, whose RBG values are (179, 27, 27), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cornflower Blue (Crayola), whose RBG values are (154, 206, 235), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Cornflower Blue (Crayola), whose RBG values are (154, 206, 235), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cornflower Blue, whose RBG values are (100, 149, 237), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cornflowerBlueColor;
/*!
* Returns a UIColor object representing the color Cornflower Blue, whose RBG values are (100, 149, 237), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cornsilk, whose RBG values are (255, 248, 220), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cornsilkColor;
/*!
* Returns a UIColor object representing the color Cornsilk, whose RBG values are (255, 248, 220), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cosmic Latte, whose RBG values are (255, 248, 231), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cosmicLatteColor;
/*!
* Returns a UIColor object representing the color Cosmic Latte, whose RBG values are (255, 248, 231), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cotton Candy (Crayola), whose RBG values are (255, 188, 217), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Cotton Candy (Crayola), whose RBG values are (255, 188, 217), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Coyote Brown, whose RBG values are (129, 97, 60), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) coyoteBrownColor;
/*!
* Returns a UIColor object representing the color Coyote Brown, whose RBG values are (129, 97, 60), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cream, whose RBG values are (255, 253, 208), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) creamColor;
/*!
* Returns a UIColor object representing the color Cream, whose RBG values are (255, 253, 208), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) creamColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Crimson, whose RBG values are (220, 20, 60), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) crimsonColor;
/*!
* Returns a UIColor object representing the color Crimson, whose RBG values are (220, 20, 60), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Crimson Glory, whose RBG values are (190, 0, 50), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) crimsonGloryColor;
/*!
* Returns a UIColor object representing the color Crimson Glory, whose RBG values are (190, 0, 50), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Crimson Red, whose RBG values are (153, 0, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) crimsonRedColor;
/*!
* Returns a UIColor object representing the color Crimson Red, whose RBG values are (153, 0, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cyan (Process), whose RBG values are (0, 183, 235), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cyanProcessColor;
/*!
* Returns a UIColor object representing the color Cyan (Process), whose RBG values are (0, 183, 235), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cyan 100, whose RBG values are (178, 235, 242), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cyan100Color;
/*!
* Returns a UIColor object representing the color Cyan 100, whose RBG values are (178, 235, 242), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cyan 200, whose RBG values are (128, 222, 234), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cyan200Color;
/*!
* Returns a UIColor object representing the color Cyan 200, whose RBG values are (128, 222, 234), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cyan 300, whose RBG values are (77, 208, 225), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cyan300Color;
/*!
* Returns a UIColor object representing the color Cyan 300, whose RBG values are (77, 208, 225), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cyan 400, whose RBG values are (38, 198, 218), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cyan400Color;
/*!
* Returns a UIColor object representing the color Cyan 400, whose RBG values are (38, 198, 218), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cyan 50, whose RBG values are (224, 247, 250), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cyan50Color;
/*!
* Returns a UIColor object representing the color Cyan 50, whose RBG values are (224, 247, 250), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cyan 500, whose RBG values are (0, 188, 212), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cyan500Color;
/*!
* Returns a UIColor object representing the color Cyan 500, whose RBG values are (0, 188, 212), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cyan 600, whose RBG values are (0, 172, 193), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cyan600Color;
/*!
* Returns a UIColor object representing the color Cyan 600, whose RBG values are (0, 172, 193), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cyan 700, whose RBG values are (0, 151, 167), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cyan700Color;
/*!
* Returns a UIColor object representing the color Cyan 700, whose RBG values are (0, 151, 167), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cyan 800, whose RBG values are (0, 131, 143), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cyan800Color;
/*!
* Returns a UIColor object representing the color Cyan 800, whose RBG values are (0, 131, 143), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cyan 900, whose RBG values are (0, 96, 100), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cyan900Color;
/*!
* Returns a UIColor object representing the color Cyan 900, whose RBG values are (0, 96, 100), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cyan A100, whose RBG values are (132, 255, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cyanA100Color;
/*!
* Returns a UIColor object representing the color Cyan A100, whose RBG values are (132, 255, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cyan A200, whose RBG values are (24, 255, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cyanA200Color;
/*!
* Returns a UIColor object representing the color Cyan A200, whose RBG values are (24, 255, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cyan A400, whose RBG values are (0, 229, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cyanA400Color;
/*!
* Returns a UIColor object representing the color Cyan A400, whose RBG values are (0, 229, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cyan A700, whose RBG values are (0, 184, 212), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cyanA700Color;
/*!
* Returns a UIColor object representing the color Cyan A700, whose RBG values are (0, 184, 212), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cyan Azure, whose RBG values are (78, 130, 180), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cyanAzureColor;
/*!
* Returns a UIColor object representing the color Cyan Azure, whose RBG values are (78, 130, 180), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cyan Cobalt Blue, whose RBG values are (40, 88, 156), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cyanCobaltBlueColor;
/*!
* Returns a UIColor object representing the color Cyan Cobalt Blue, whose RBG values are (40, 88, 156), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cyan Cornflower Blue, whose RBG values are (24, 139, 194), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Cyan Cornflower Blue, whose RBG values are (24, 139, 194), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cyan-Blue Azure, whose RBG values are (70, 130, 191), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cyanBlueAzureColor;
/*!
* Returns a UIColor object representing the color Cyan-Blue Azure, whose RBG values are (70, 130, 191), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cyber Grape, whose RBG values are (88, 66, 124), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cyberGrapeColor;
/*!
* Returns a UIColor object representing the color Cyber Grape, whose RBG values are (88, 66, 124), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Cyber Yellow, whose RBG values are (255, 211, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) cyberYellowColor;
/*!
* Returns a UIColor object representing the color Cyber Yellow, whose RBG values are (255, 211, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Daffodil, whose RBG values are (255, 255, 49), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) daffodilColor;
/*!
* Returns a UIColor object representing the color Daffodil, whose RBG values are (255, 255, 49), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dandelion, whose RBG values are (240, 225, 48), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) dandelionColor;
/*!
* Returns a UIColor object representing the color Dandelion, whose RBG values are (240, 225, 48), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dandelion (Crayola), whose RBG values are (253, 219, 109), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Dandelion (Crayola), whose RBG values are (253, 219, 109), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Blue, whose RBG values are (0, 0, 139), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkBlueColor;
/*!
* Returns a UIColor object representing the color Dark Blue, whose RBG values are (0, 0, 139), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Blue-Gray, whose RBG values are (102, 102, 153), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkBlueGrayColor;
/*!
* Returns a UIColor object representing the color Dark Blue-Gray, whose RBG values are (102, 102, 153), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Brown, whose RBG values are (101, 67, 33), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkBrownColor;
/*!
* Returns a UIColor object representing the color Dark Brown, whose RBG values are (101, 67, 33), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Brown-Tangelo, whose RBG values are (136, 101, 78), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Dark Brown-Tangelo, whose RBG values are (136, 101, 78), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Byzantium, whose RBG values are (93, 57, 84), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkByzantiumColor;
/*!
* Returns a UIColor object representing the color Dark Byzantium, whose RBG values are (93, 57, 84), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Candy Apple Red, whose RBG values are (164, 0, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Dark Candy Apple Red, whose RBG values are (164, 0, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Cerulean, whose RBG values are (8, 69, 126), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkCeruleanColor;
/*!
* Returns a UIColor object representing the color Dark Cerulean, whose RBG values are (8, 69, 126), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Chestnut, whose RBG values are (152, 105, 96), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkChestnutColor;
/*!
* Returns a UIColor object representing the color Dark Chestnut, whose RBG values are (152, 105, 96), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Coral, whose RBG values are (205, 91, 69), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkCoralColor;
/*!
* Returns a UIColor object representing the color Dark Coral, whose RBG values are (205, 91, 69), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Cyan, whose RBG values are (0, 139, 139), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkCyanColor;
/*!
* Returns a UIColor object representing the color Dark Cyan, whose RBG values are (0, 139, 139), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Electric Blue, whose RBG values are (83, 104, 120), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Dark Electric Blue, whose RBG values are (83, 104, 120), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Goldenrod, whose RBG values are (184, 134, 11), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkGoldenrodColor;
/*!
* Returns a UIColor object representing the color Dark Goldenrod, whose RBG values are (184, 134, 11), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Gray (X11), whose RBG values are (169, 169, 169), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkGrayX11Color;
/*!
* Returns a UIColor object representing the color Dark Gray (X11), whose RBG values are (169, 169, 169), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Green, whose RBG values are (1, 50, 32), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkGreenColor;
/*!
* Returns a UIColor object representing the color Dark Green, whose RBG values are (1, 50, 32), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Green (X11), whose RBG values are (0, 100, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkGreenX11Color;
/*!
* Returns a UIColor object representing the color Dark Green (X11), whose RBG values are (0, 100, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Gunmetal, whose RBG values are (31, 38, 42), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkGunmetalColor;
/*!
* Returns a UIColor object representing the color Dark Gunmetal, whose RBG values are (31, 38, 42), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Imperial Blue 1, whose RBG values are (0, 65, 106), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Dark Imperial Blue 1, whose RBG values are (0, 65, 106), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Imperial Blue 2, whose RBG values are (0, 20, 126), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Dark Imperial Blue 2, whose RBG values are (0, 20, 126), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Jungle Green, whose RBG values are (26, 36, 33), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Dark Jungle Green, whose RBG values are (26, 36, 33), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Khaki, whose RBG values are (189, 183, 107), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkKhakiColor;
/*!
* Returns a UIColor object representing the color Dark Khaki, whose RBG values are (189, 183, 107), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Lava, whose RBG values are (72, 60, 50), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkLavaColor;
/*!
* Returns a UIColor object representing the color Dark Lava, whose RBG values are (72, 60, 50), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Lavender, whose RBG values are (115, 79, 150), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkLavenderColor;
/*!
* Returns a UIColor object representing the color Dark Lavender, whose RBG values are (115, 79, 150), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Liver, whose RBG values are (83, 75, 79), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkLiverColor;
/*!
* Returns a UIColor object representing the color Dark Liver, whose RBG values are (83, 75, 79), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Liver (Horses), whose RBG values are (84, 61, 55), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Dark Liver (Horses), whose RBG values are (84, 61, 55), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Magenta, whose RBG values are (139, 0, 139), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkMagentaColor;
/*!
* Returns a UIColor object representing the color Dark Magenta, whose RBG values are (139, 0, 139), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Medium Gray, whose RBG values are (169, 169, 169), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkMediumGrayColor;
/*!
* Returns a UIColor object representing the color Dark Medium Gray, whose RBG values are (169, 169, 169), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Midnight Blue, whose RBG values are (0, 51, 102), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Dark Midnight Blue, whose RBG values are (0, 51, 102), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Moss Green, whose RBG values are (74, 93, 35), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkMossGreenColor;
/*!
* Returns a UIColor object representing the color Dark Moss Green, whose RBG values are (74, 93, 35), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Olive Green, whose RBG values are (85, 107, 47), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkOliveGreenColor;
/*!
* Returns a UIColor object representing the color Dark Olive Green, whose RBG values are (85, 107, 47), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Orange, whose RBG values are (255, 140, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkOrangeColor;
/*!
* Returns a UIColor object representing the color Dark Orange, whose RBG values are (255, 140, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Orchid, whose RBG values are (153, 50, 204), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkOrchidColor;
/*!
* Returns a UIColor object representing the color Dark Orchid, whose RBG values are (153, 50, 204), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Pastel Blue, whose RBG values are (119, 158, 203), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkPastelBlueColor;
/*!
* Returns a UIColor object representing the color Dark Pastel Blue, whose RBG values are (119, 158, 203), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Pastel Green, whose RBG values are (3, 192, 60), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Dark Pastel Green, whose RBG values are (3, 192, 60), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Pastel Purple, whose RBG values are (150, 111, 214), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Dark Pastel Purple, whose RBG values are (150, 111, 214), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Pastel Red, whose RBG values are (194, 59, 34), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkPastelRedColor;
/*!
* Returns a UIColor object representing the color Dark Pastel Red, whose RBG values are (194, 59, 34), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Pink, whose RBG values are (231, 84, 128), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkPinkColor;
/*!
* Returns a UIColor object representing the color Dark Pink, whose RBG values are (231, 84, 128), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Powder Blue, whose RBG values are (0, 51, 153), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkPowderBlueColor;
/*!
* Returns a UIColor object representing the color Dark Powder Blue, whose RBG values are (0, 51, 153), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Puce, whose RBG values are (79, 58, 60), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkPuceColor;
/*!
* Returns a UIColor object representing the color Dark Puce, whose RBG values are (79, 58, 60), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Purple, whose RBG values are (48, 25, 52), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkPurpleColor;
/*!
* Returns a UIColor object representing the color Dark Purple, whose RBG values are (48, 25, 52), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Raspberry, whose RBG values are (135, 38, 87), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkRaspberryColor;
/*!
* Returns a UIColor object representing the color Dark Raspberry, whose RBG values are (135, 38, 87), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Red, whose RBG values are (139, 0, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkRedColor;
/*!
* Returns a UIColor object representing the color Dark Red, whose RBG values are (139, 0, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Salmon, whose RBG values are (233, 150, 122), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkSalmonColor;
/*!
* Returns a UIColor object representing the color Dark Salmon, whose RBG values are (233, 150, 122), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Scarlet, whose RBG values are (86, 3, 25), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkScarletColor;
/*!
* Returns a UIColor object representing the color Dark Scarlet, whose RBG values are (86, 3, 25), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Sea Green, whose RBG values are (143, 188, 143), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkSeaGreenColor;
/*!
* Returns a UIColor object representing the color Dark Sea Green, whose RBG values are (143, 188, 143), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Sienna, whose RBG values are (60, 20, 20), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkSiennaColor;
/*!
* Returns a UIColor object representing the color Dark Sienna, whose RBG values are (60, 20, 20), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Sky Blue, whose RBG values are (140, 190, 214), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkSkyBlueColor;
/*!
* Returns a UIColor object representing the color Dark Sky Blue, whose RBG values are (140, 190, 214), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Slate Blue, whose RBG values are (72, 61, 139), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkSlateBlueColor;
/*!
* Returns a UIColor object representing the color Dark Slate Blue, whose RBG values are (72, 61, 139), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Slate Gray, whose RBG values are (47, 79, 79), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkSlateGrayColor;
/*!
* Returns a UIColor object representing the color Dark Slate Gray, whose RBG values are (47, 79, 79), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Spring Green, whose RBG values are (23, 114, 69), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Dark Spring Green, whose RBG values are (23, 114, 69), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Tan, whose RBG values are (145, 129, 81), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkTanColor;
/*!
* Returns a UIColor object representing the color Dark Tan, whose RBG values are (145, 129, 81), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Tangerine, whose RBG values are (255, 168, 18), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkTangerineColor;
/*!
* Returns a UIColor object representing the color Dark Tangerine, whose RBG values are (255, 168, 18), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Taupe, whose RBG values are (72, 60, 50), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkTaupeColor;
/*!
* Returns a UIColor object representing the color Dark Taupe, whose RBG values are (72, 60, 50), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Terra Cotta, whose RBG values are (204, 78, 92), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkTerraCottaColor;
/*!
* Returns a UIColor object representing the color Dark Terra Cotta, whose RBG values are (204, 78, 92), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Turquoise, whose RBG values are (0, 206, 209), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkTurquoiseColor;
/*!
* Returns a UIColor object representing the color Dark Turquoise, whose RBG values are (0, 206, 209), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Vanilla, whose RBG values are (209, 190, 168), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkVanillaColor;
/*!
* Returns a UIColor object representing the color Dark Vanilla, whose RBG values are (209, 190, 168), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Violet, whose RBG values are (148, 0, 211), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkVioletColor;
/*!
* Returns a UIColor object representing the color Dark Violet, whose RBG values are (148, 0, 211), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dark Yellow, whose RBG values are (155, 135, 12), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) darkYellowColor;
/*!
* Returns a UIColor object representing the color Dark Yellow, whose RBG values are (155, 135, 12), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dartmouth Green, whose RBG values are (0, 112, 60), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) dartmouthGreenColor;
/*!
* Returns a UIColor object representing the color Dartmouth Green, whose RBG values are (0, 112, 60), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Davy's Grey, whose RBG values are (85, 85, 85), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) davysGreyColor;
/*!
* Returns a UIColor object representing the color Davy's Grey, whose RBG values are (85, 85, 85), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Debian Red, whose RBG values are (215, 10, 83), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) debianRedColor;
/*!
* Returns a UIColor object representing the color Debian Red, whose RBG values are (215, 10, 83), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Green, whose RBG values are (5, 102, 8), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepGreenColor;
/*!
* Returns a UIColor object representing the color Deep Green, whose RBG values are (5, 102, 8), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Orange 100, whose RBG values are (255, 204, 188), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepOrange100Color;
/*!
* Returns a UIColor object representing the color Deep Orange 100, whose RBG values are (255, 204, 188), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Orange 200, whose RBG values are (255, 171, 145), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepOrange200Color;
/*!
* Returns a UIColor object representing the color Deep Orange 200, whose RBG values are (255, 171, 145), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Orange 300, whose RBG values are (255, 138, 101), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepOrange300Color;
/*!
* Returns a UIColor object representing the color Deep Orange 300, whose RBG values are (255, 138, 101), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Orange 400, whose RBG values are (255, 112, 67), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepOrange400Color;
/*!
* Returns a UIColor object representing the color Deep Orange 400, whose RBG values are (255, 112, 67), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Orange 50, whose RBG values are (251, 233, 231), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepOrange50Color;
/*!
* Returns a UIColor object representing the color Deep Orange 50, whose RBG values are (251, 233, 231), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Orange 500, whose RBG values are (255, 87, 34), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepOrange500Color;
/*!
* Returns a UIColor object representing the color Deep Orange 500, whose RBG values are (255, 87, 34), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Orange 600, whose RBG values are (244, 81, 30), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepOrange600Color;
/*!
* Returns a UIColor object representing the color Deep Orange 600, whose RBG values are (244, 81, 30), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Orange 700, whose RBG values are (230, 74, 25), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepOrange700Color;
/*!
* Returns a UIColor object representing the color Deep Orange 700, whose RBG values are (230, 74, 25), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Orange 800, whose RBG values are (216, 67, 21), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepOrange800Color;
/*!
* Returns a UIColor object representing the color Deep Orange 800, whose RBG values are (216, 67, 21), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Orange 900, whose RBG values are (191, 54, 12), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepOrange900Color;
/*!
* Returns a UIColor object representing the color Deep Orange 900, whose RBG values are (191, 54, 12), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Orange A100, whose RBG values are (255, 158, 128), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepOrangeA100Color;
/*!
* Returns a UIColor object representing the color Deep Orange A100, whose RBG values are (255, 158, 128), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Orange A200, whose RBG values are (255, 110, 64), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepOrangeA200Color;
/*!
* Returns a UIColor object representing the color Deep Orange A200, whose RBG values are (255, 110, 64), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Orange A400, whose RBG values are (255, 61, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepOrangeA400Color;
/*!
* Returns a UIColor object representing the color Deep Orange A400, whose RBG values are (255, 61, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Orange A700, whose RBG values are (221, 44, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepOrangeA700Color;
/*!
* Returns a UIColor object representing the color Deep Orange A700, whose RBG values are (221, 44, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Purple 100, whose RBG values are (209, 196, 233), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepPurple100Color;
/*!
* Returns a UIColor object representing the color Deep Purple 100, whose RBG values are (209, 196, 233), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Purple 200, whose RBG values are (179, 157, 219), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepPurple200Color;
/*!
* Returns a UIColor object representing the color Deep Purple 200, whose RBG values are (179, 157, 219), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Purple 300, whose RBG values are (149, 117, 205), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepPurple300Color;
/*!
* Returns a UIColor object representing the color Deep Purple 300, whose RBG values are (149, 117, 205), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Purple 400, whose RBG values are (126, 87, 194), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepPurple400Color;
/*!
* Returns a UIColor object representing the color Deep Purple 400, whose RBG values are (126, 87, 194), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Purple 50, whose RBG values are (237, 231, 246), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepPurple50Color;
/*!
* Returns a UIColor object representing the color Deep Purple 50, whose RBG values are (237, 231, 246), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Purple 500, whose RBG values are (103, 58, 183), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepPurple500Color;
/*!
* Returns a UIColor object representing the color Deep Purple 500, whose RBG values are (103, 58, 183), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Purple 600, whose RBG values are (94, 53, 177), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepPurple600Color;
/*!
* Returns a UIColor object representing the color Deep Purple 600, whose RBG values are (94, 53, 177), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Purple 700, whose RBG values are (81, 45, 168), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepPurple700Color;
/*!
* Returns a UIColor object representing the color Deep Purple 700, whose RBG values are (81, 45, 168), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Purple 800, whose RBG values are (69, 39, 160), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepPurple800Color;
/*!
* Returns a UIColor object representing the color Deep Purple 800, whose RBG values are (69, 39, 160), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Purple 900, whose RBG values are (49, 27, 146), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepPurple900Color;
/*!
* Returns a UIColor object representing the color Deep Purple 900, whose RBG values are (49, 27, 146), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Purple A100, whose RBG values are (179, 136, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepPurpleA100Color;
/*!
* Returns a UIColor object representing the color Deep Purple A100, whose RBG values are (179, 136, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Purple A200, whose RBG values are (124, 77, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepPurpleA200Color;
/*!
* Returns a UIColor object representing the color Deep Purple A200, whose RBG values are (124, 77, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Purple A400, whose RBG values are (101, 31, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepPurpleA400Color;
/*!
* Returns a UIColor object representing the color Deep Purple A400, whose RBG values are (101, 31, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Purple A700, whose RBG values are (98, 0, 234), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepPurpleA700Color;
/*!
* Returns a UIColor object representing the color Deep Purple A700, whose RBG values are (98, 0, 234), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Red, whose RBG values are (133, 1, 1), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepRedColor;
/*!
* Returns a UIColor object representing the color Deep Red, whose RBG values are (133, 1, 1), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Space Sparkle, whose RBG values are (74, 100, 108), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Deep Space Sparkle, whose RBG values are (74, 100, 108), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Taupe, whose RBG values are (126, 94, 96), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepTaupeColor;
/*!
* Returns a UIColor object representing the color Deep Taupe, whose RBG values are (126, 94, 96), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Tuscan Red, whose RBG values are (102, 66, 77), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepTuscanRedColor;
/*!
* Returns a UIColor object representing the color Deep Tuscan Red, whose RBG values are (102, 66, 77), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Aquamarine, whose RBG values are (64, 130, 109), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepAquamarineColor;
/*!
* Returns a UIColor object representing the color Deep Aquamarine, whose RBG values are (64, 130, 109), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Carmine, whose RBG values are (169, 32, 62), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepCarmineColor;
/*!
* Returns a UIColor object representing the color Deep Carmine, whose RBG values are (169, 32, 62), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Carmine Pink, whose RBG values are (239, 48, 56), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Deep Carmine Pink, whose RBG values are (239, 48, 56), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Carrot Orange, whose RBG values are (233, 105, 44), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Deep Carrot Orange, whose RBG values are (233, 105, 44), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Cerise, whose RBG values are (218, 50, 135), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepCeriseColor;
/*!
* Returns a UIColor object representing the color Deep Cerise, whose RBG values are (218, 50, 135), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Champagne, whose RBG values are (250, 214, 165), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepChampagneColor;
/*!
* Returns a UIColor object representing the color Deep Champagne, whose RBG values are (250, 214, 165), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Chestnut, whose RBG values are (185, 78, 72), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepChestnutColor;
/*!
* Returns a UIColor object representing the color Deep Chestnut, whose RBG values are (185, 78, 72), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Coffee, whose RBG values are (112, 66, 65), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepCoffeeColor;
/*!
* Returns a UIColor object representing the color Deep Coffee, whose RBG values are (112, 66, 65), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Fuchsia, whose RBG values are (193, 84, 193), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepFuchsiaColor;
/*!
* Returns a UIColor object representing the color Deep Fuchsia, whose RBG values are (193, 84, 193), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Green-Cyan Turquoise, whose RBG values are (14, 124, 97), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Deep Green-Cyan Turquoise, whose RBG values are (14, 124, 97), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Jungle Green, whose RBG values are (0, 75, 73), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Deep Jungle Green, whose RBG values are (0, 75, 73), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Koamaru, whose RBG values are (51, 51, 102), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepKoamaruColor;
/*!
* Returns a UIColor object representing the color Deep Koamaru, whose RBG values are (51, 51, 102), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Lemon, whose RBG values are (245, 199, 26), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepLemonColor;
/*!
* Returns a UIColor object representing the color Deep Lemon, whose RBG values are (245, 199, 26), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Lilac, whose RBG values are (153, 85, 187), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepLilacColor;
/*!
* Returns a UIColor object representing the color Deep Lilac, whose RBG values are (153, 85, 187), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Magenta, whose RBG values are (204, 0, 204), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepMagentaColor;
/*!
* Returns a UIColor object representing the color Deep Magenta, whose RBG values are (204, 0, 204), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Maroon, whose RBG values are (130, 0, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepMaroonColor;
/*!
* Returns a UIColor object representing the color Deep Maroon, whose RBG values are (130, 0, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Mauve, whose RBG values are (212, 115, 212), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepMauveColor;
/*!
* Returns a UIColor object representing the color Deep Mauve, whose RBG values are (212, 115, 212), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Moss Green, whose RBG values are (53, 94, 59), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepMossGreenColor;
/*!
* Returns a UIColor object representing the color Deep Moss Green, whose RBG values are (53, 94, 59), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Peach, whose RBG values are (255, 203, 164), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepPeachColor;
/*!
* Returns a UIColor object representing the color Deep Peach, whose RBG values are (255, 203, 164), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Pink, whose RBG values are (255, 20, 147), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepPinkColor;
/*!
* Returns a UIColor object representing the color Deep Pink, whose RBG values are (255, 20, 147), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Puce, whose RBG values are (169, 92, 104), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepPuceColor;
/*!
* Returns a UIColor object representing the color Deep Puce, whose RBG values are (169, 92, 104), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Ruby, whose RBG values are (132, 63, 91), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepRubyColor;
/*!
* Returns a UIColor object representing the color Deep Ruby, whose RBG values are (132, 63, 91), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Saffron, whose RBG values are (255, 153, 51), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepSaffronColor;
/*!
* Returns a UIColor object representing the color Deep Saffron, whose RBG values are (255, 153, 51), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Sky Blue, whose RBG values are (0, 191, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepSkyBlueColor;
/*!
* Returns a UIColor object representing the color Deep Sky Blue, whose RBG values are (0, 191, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Spring Bud, whose RBG values are (85, 107, 47), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepSpringBudColor;
/*!
* Returns a UIColor object representing the color Deep Spring Bud, whose RBG values are (85, 107, 47), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deep Violet, whose RBG values are (51, 0, 102), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deepVioletColor;
/*!
* Returns a UIColor object representing the color Deep Violet, whose RBG values are (51, 0, 102), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Deer, whose RBG values are (186, 135, 89), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deerColor;
/*!
* Returns a UIColor object representing the color Deer, whose RBG values are (186, 135, 89), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) deerColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Denim, whose RBG values are (21, 96, 189), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) denimColor;
/*!
* Returns a UIColor object representing the color Denim, whose RBG values are (21, 96, 189), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) denimColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Denim (Crayola), whose RBG values are (43, 108, 196), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) denimCrayolaColor;
/*!
* Returns a UIColor object representing the color Denim (Crayola), whose RBG values are (43, 108, 196), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Desaturated Cyan, whose RBG values are (102, 153, 153), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Desaturated Cyan, whose RBG values are (102, 153, 153), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Desert, whose RBG values are (193, 154, 107), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) desertColor;
/*!
* Returns a UIColor object representing the color Desert, whose RBG values are (193, 154, 107), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Desert Sand (Crayola), whose RBG values are (239, 205, 184), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Desert Sand (Crayola), whose RBG values are (239, 205, 184), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Desert Sand, whose RBG values are (237, 201, 175), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) desertSandColor;
/*!
* Returns a UIColor object representing the color Desert Sand, whose RBG values are (237, 201, 175), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Desire, whose RBG values are (234, 60, 83), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) desireColor;
/*!
* Returns a UIColor object representing the color Desire, whose RBG values are (234, 60, 83), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Diamond, whose RBG values are (185, 242, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) diamondColor;
/*!
* Returns a UIColor object representing the color Diamond, whose RBG values are (185, 242, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dim Gray, whose RBG values are (105, 105, 105), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) dimGrayColor;
/*!
* Returns a UIColor object representing the color Dim Gray, whose RBG values are (105, 105, 105), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dirt, whose RBG values are (155, 118, 83), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) dirtColor;
/*!
* Returns a UIColor object representing the color Dirt, whose RBG values are (155, 118, 83), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) dirtColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dodger Blue, whose RBG values are (30, 144, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) dodgerBlueColor;
/*!
* Returns a UIColor object representing the color Dodger Blue, whose RBG values are (30, 144, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dogwood Rose, whose RBG values are (215, 24, 104), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) dogwoodRoseColor;
/*!
* Returns a UIColor object representing the color Dogwood Rose, whose RBG values are (215, 24, 104), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dollar Bill, whose RBG values are (133, 187, 101), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) dollarBillColor;
/*!
* Returns a UIColor object representing the color Dollar Bill, whose RBG values are (133, 187, 101), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Donkey Brown, whose RBG values are (102, 76, 40), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) donkeyBrownColor;
/*!
* Returns a UIColor object representing the color Donkey Brown, whose RBG values are (102, 76, 40), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Drab, whose RBG values are (150, 113, 23), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) drabColor;
/*!
* Returns a UIColor object representing the color Drab, whose RBG values are (150, 113, 23), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) drabColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Duke Blue, whose RBG values are (0, 0, 156), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) dukeBlueColor;
/*!
* Returns a UIColor object representing the color Duke Blue, whose RBG values are (0, 0, 156), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dust Storm, whose RBG values are (229, 204, 201), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) dustStormColor;
/*!
* Returns a UIColor object representing the color Dust Storm, whose RBG values are (229, 204, 201), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Dutch White, whose RBG values are (239, 223, 187), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) dutchWhiteColor;
/*!
* Returns a UIColor object representing the color Dutch White, whose RBG values are (239, 223, 187), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Eagle Green, whose RBG values are (0, 73, 83), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) eagleGreenColor;
/*!
* Returns a UIColor object representing the color Eagle Green, whose RBG values are (0, 73, 83), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Earth Yellow, whose RBG values are (225, 169, 95), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) earthYellowColor;
/*!
* Returns a UIColor object representing the color Earth Yellow, whose RBG values are (225, 169, 95), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ebony, whose RBG values are (85, 93, 80), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ebonyColor;
/*!
* Returns a UIColor object representing the color Ebony, whose RBG values are (85, 93, 80), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ebonyColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ecru, whose RBG values are (194, 178, 128), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ecruColor;
/*!
* Returns a UIColor object representing the color Ecru, whose RBG values are (194, 178, 128), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ecruColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Eerie Black, whose RBG values are (27, 27, 27), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) eerieBlackColor;
/*!
* Returns a UIColor object representing the color Eerie Black, whose RBG values are (27, 27, 27), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Eggplant, whose RBG values are (97, 64, 81), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) eggplantColor;
/*!
* Returns a UIColor object representing the color Eggplant, whose RBG values are (97, 64, 81), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Eggplant (Crayola), whose RBG values are (110, 81, 96), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Eggplant (Crayola), whose RBG values are (110, 81, 96), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Eggshell, whose RBG values are (240, 234, 214), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) eggshellColor;
/*!
* Returns a UIColor object representing the color Eggshell, whose RBG values are (240, 234, 214), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Egyptian Blue, whose RBG values are (16, 52, 166), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) egyptianBlueColor;
/*!
* Returns a UIColor object representing the color Egyptian Blue, whose RBG values are (16, 52, 166), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Electric Lime (Crayola), whose RBG values are (206, 255, 29), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Electric Lime (Crayola), whose RBG values are (206, 255, 29), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Electric Blue, whose RBG values are (125, 249, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) electricBlueColor;
/*!
* Returns a UIColor object representing the color Electric Blue, whose RBG values are (125, 249, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Electric Crimson, whose RBG values are (255, 0, 63), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Electric Crimson, whose RBG values are (255, 0, 63), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Electric Cyan, whose RBG values are (0, 255, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) electricCyanColor;
/*!
* Returns a UIColor object representing the color Electric Cyan, whose RBG values are (0, 255, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Electric Green, whose RBG values are (0, 255, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) electricGreenColor;
/*!
* Returns a UIColor object representing the color Electric Green, whose RBG values are (0, 255, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Electric Indigo, whose RBG values are (111, 0, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) electricIndigoColor;
/*!
* Returns a UIColor object representing the color Electric Indigo, whose RBG values are (111, 0, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Electric Lavender, whose RBG values are (244, 187, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Electric Lavender, whose RBG values are (244, 187, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Electric Lime, whose RBG values are (204, 255, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) electricLimeColor;
/*!
* Returns a UIColor object representing the color Electric Lime, whose RBG values are (204, 255, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Electric Purple, whose RBG values are (191, 0, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) electricPurpleColor;
/*!
* Returns a UIColor object representing the color Electric Purple, whose RBG values are (191, 0, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Electric Ultramarine, whose RBG values are (63, 0, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Electric Ultramarine, whose RBG values are (63, 0, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Electric Violet, whose RBG values are (143, 0, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) electricVioletColor;
/*!
* Returns a UIColor object representing the color Electric Violet, whose RBG values are (143, 0, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Electric Yellow, whose RBG values are (255, 255, 51), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) electricYellowColor;
/*!
* Returns a UIColor object representing the color Electric Yellow, whose RBG values are (255, 255, 51), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Emerald, whose RBG values are (80, 200, 120), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) emeraldColor;
/*!
* Returns a UIColor object representing the color Emerald, whose RBG values are (80, 200, 120), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Eminence, whose RBG values are (108, 48, 130), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) eminenceColor;
/*!
* Returns a UIColor object representing the color Eminence, whose RBG values are (108, 48, 130), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color English Green, whose RBG values are (27, 77, 62), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) englishGreenColor;
/*!
* Returns a UIColor object representing the color English Green, whose RBG values are (27, 77, 62), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color English Lavender, whose RBG values are (180, 131, 149), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color English Lavender, whose RBG values are (180, 131, 149), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color English Red, whose RBG values are (171, 75, 82), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) englishRedColor;
/*!
* Returns a UIColor object representing the color English Red, whose RBG values are (171, 75, 82), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color English Violet, whose RBG values are (86, 60, 92), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) englishVioletColor;
/*!
* Returns a UIColor object representing the color English Violet, whose RBG values are (86, 60, 92), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Eton Blue, whose RBG values are (150, 200, 162), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) etonBlueColor;
/*!
* Returns a UIColor object representing the color Eton Blue, whose RBG values are (150, 200, 162), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Eucalyptus, whose RBG values are (68, 215, 168), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) eucalyptusColor;
/*!
* Returns a UIColor object representing the color Eucalyptus, whose RBG values are (68, 215, 168), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Fallow, whose RBG values are (193, 154, 107), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) fallowColor;
/*!
* Returns a UIColor object representing the color Fallow, whose RBG values are (193, 154, 107), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Falu Red, whose RBG values are (128, 24, 24), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) faluRedColor;
/*!
* Returns a UIColor object representing the color Falu Red, whose RBG values are (128, 24, 24), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Fandango, whose RBG values are (181, 51, 137), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) fandangoColor;
/*!
* Returns a UIColor object representing the color Fandango, whose RBG values are (181, 51, 137), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Fandango Pink, whose RBG values are (222, 82, 133), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) fandangoPinkColor;
/*!
* Returns a UIColor object representing the color Fandango Pink, whose RBG values are (222, 82, 133), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Fashion Fuchsia, whose RBG values are (244, 0, 161), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) fashionFuchsiaColor;
/*!
* Returns a UIColor object representing the color Fashion Fuchsia, whose RBG values are (244, 0, 161), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Fawn, whose RBG values are (229, 170, 112), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) fawnColor;
/*!
* Returns a UIColor object representing the color Fawn, whose RBG values are (229, 170, 112), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) fawnColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Feldgrau, whose RBG values are (77, 93, 83), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) feldgrauColor;
/*!
* Returns a UIColor object representing the color Feldgrau, whose RBG values are (77, 93, 83), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Feldspar, whose RBG values are (253, 213, 177), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) feldsparColor;
/*!
* Returns a UIColor object representing the color Feldspar, whose RBG values are (253, 213, 177), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Fern (Crayola), whose RBG values are (113, 188, 120), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) fernCrayolaColor;
/*!
* Returns a UIColor object representing the color Fern (Crayola), whose RBG values are (113, 188, 120), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Fern Green, whose RBG values are (79, 121, 66), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) fernGreenColor;
/*!
* Returns a UIColor object representing the color Fern Green, whose RBG values are (79, 121, 66), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ferrari Red, whose RBG values are (255, 40, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ferrariRedColor;
/*!
* Returns a UIColor object representing the color Ferrari Red, whose RBG values are (255, 40, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Field Drab, whose RBG values are (108, 84, 30), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) fieldDrabColor;
/*!
* Returns a UIColor object representing the color Field Drab, whose RBG values are (108, 84, 30), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Fire Engine Red, whose RBG values are (206, 32, 41), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) fireEngineRedColor;
/*!
* Returns a UIColor object representing the color Fire Engine Red, whose RBG values are (206, 32, 41), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Firebrick, whose RBG values are (178, 34, 34), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) firebrickColor;
/*!
* Returns a UIColor object representing the color Firebrick, whose RBG values are (178, 34, 34), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Flame, whose RBG values are (226, 88, 34), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) flameColor;
/*!
* Returns a UIColor object representing the color Flame, whose RBG values are (226, 88, 34), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) flameColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Flamingo Pink, whose RBG values are (252, 142, 172), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) flamingoPinkColor;
/*!
* Returns a UIColor object representing the color Flamingo Pink, whose RBG values are (252, 142, 172), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Flattery, whose RBG values are (107, 68, 35), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) flatteryColor;
/*!
* Returns a UIColor object representing the color Flattery, whose RBG values are (107, 68, 35), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Flavescent, whose RBG values are (247, 233, 142), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) flavescentColor;
/*!
* Returns a UIColor object representing the color Flavescent, whose RBG values are (247, 233, 142), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Flax, whose RBG values are (238, 220, 130), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) flaxColor;
/*!
* Returns a UIColor object representing the color Flax, whose RBG values are (238, 220, 130), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) flaxColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Flirt, whose RBG values are (162, 0, 109), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) flirtColor;
/*!
* Returns a UIColor object representing the color Flirt, whose RBG values are (162, 0, 109), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) flirtColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Floral White, whose RBG values are (255, 250, 240), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) floralWhiteColor;
/*!
* Returns a UIColor object representing the color Floral White, whose RBG values are (255, 250, 240), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Fluorescent Orange, whose RBG values are (255, 191, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Fluorescent Orange, whose RBG values are (255, 191, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Fluorescent Pink, whose RBG values are (255, 20, 147), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Fluorescent Pink, whose RBG values are (255, 20, 147), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Fluorescent Yellow, whose RBG values are (204, 255, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Fluorescent Yellow, whose RBG values are (204, 255, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Folly, whose RBG values are (255, 0, 79), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) follyColor;
/*!
* Returns a UIColor object representing the color Folly, whose RBG values are (255, 0, 79), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) follyColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Forest Green (Crayola), whose RBG values are (109, 174, 129), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Forest Green (Crayola), whose RBG values are (109, 174, 129), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Forest Green (Traditional), whose RBG values are (1, 68, 33), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Forest Green (Traditional), whose RBG values are (1, 68, 33), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Forest Green (Web), whose RBG values are (34, 139, 34), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) forestGreenWebColor;
/*!
* Returns a UIColor object representing the color Forest Green (Web), whose RBG values are (34, 139, 34), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color French Beige, whose RBG values are (166, 123, 91), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) frenchBeigeColor;
/*!
* Returns a UIColor object representing the color French Beige, whose RBG values are (166, 123, 91), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color French Bistre, whose RBG values are (133, 109, 77), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) frenchBistreColor;
/*!
* Returns a UIColor object representing the color French Bistre, whose RBG values are (133, 109, 77), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color French Blue, whose RBG values are (0, 114, 187), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) frenchBlueColor;
/*!
* Returns a UIColor object representing the color French Blue, whose RBG values are (0, 114, 187), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color French Fuchsia, whose RBG values are (253, 63, 146), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) frenchFuchsiaColor;
/*!
* Returns a UIColor object representing the color French Fuchsia, whose RBG values are (253, 63, 146), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color French Lilac, whose RBG values are (134, 96, 142), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) frenchLilacColor;
/*!
* Returns a UIColor object representing the color French Lilac, whose RBG values are (134, 96, 142), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color French Lime, whose RBG values are (158, 253, 56), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) frenchLimeColor;
/*!
* Returns a UIColor object representing the color French Lime, whose RBG values are (158, 253, 56), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color French Mauve, whose RBG values are (212, 115, 212), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) frenchMauveColor;
/*!
* Returns a UIColor object representing the color French Mauve, whose RBG values are (212, 115, 212), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color French Pink, whose RBG values are (253, 108, 158), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) frenchPinkColor;
/*!
* Returns a UIColor object representing the color French Pink, whose RBG values are (253, 108, 158), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color French Plum, whose RBG values are (129, 20, 83), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) frenchPlumColor;
/*!
* Returns a UIColor object representing the color French Plum, whose RBG values are (129, 20, 83), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color French Puce, whose RBG values are (78, 22, 9), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) frenchPuceColor;
/*!
* Returns a UIColor object representing the color French Puce, whose RBG values are (78, 22, 9), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color French Raspberry, whose RBG values are (199, 44, 72), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color French Raspberry, whose RBG values are (199, 44, 72), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color French Rose, whose RBG values are (246, 74, 138), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) frenchRoseColor;
/*!
* Returns a UIColor object representing the color French Rose, whose RBG values are (246, 74, 138), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color French Sky Blue, whose RBG values are (119, 181, 254), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) frenchSkyBlueColor;
/*!
* Returns a UIColor object representing the color French Sky Blue, whose RBG values are (119, 181, 254), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color French Violet, whose RBG values are (136, 6, 206), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) frenchVioletColor;
/*!
* Returns a UIColor object representing the color French Violet, whose RBG values are (136, 6, 206), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color French Wine, whose RBG values are (172, 30, 68), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) frenchWineColor;
/*!
* Returns a UIColor object representing the color French Wine, whose RBG values are (172, 30, 68), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Fresh Air, whose RBG values are (166, 231, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) freshAirColor;
/*!
* Returns a UIColor object representing the color Fresh Air, whose RBG values are (166, 231, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Fuchsia, whose RBG values are (255, 0, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) fuchsiaColor;
/*!
* Returns a UIColor object representing the color Fuchsia, whose RBG values are (255, 0, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Fuchsia (Crayola), whose RBG values are (195, 100, 197), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) fuchsiaCrayolaColor;
/*!
* Returns a UIColor object representing the color Fuchsia (Crayola), whose RBG values are (195, 100, 197), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Fuchsia Pink, whose RBG values are (255, 119, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) fuchsiaPinkColor;
/*!
* Returns a UIColor object representing the color Fuchsia Pink, whose RBG values are (255, 119, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Fuchsia Purple, whose RBG values are (204, 57, 123), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) fuchsiaPurpleColor;
/*!
* Returns a UIColor object representing the color Fuchsia Purple, whose RBG values are (204, 57, 123), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Fuchsia Rose, whose RBG values are (199, 67, 117), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) fuchsiaRoseColor;
/*!
* Returns a UIColor object representing the color Fuchsia Rose, whose RBG values are (199, 67, 117), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Fulvous, whose RBG values are (228, 132, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) fulvousColor;
/*!
* Returns a UIColor object representing the color Fulvous, whose RBG values are (228, 132, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Fuzzy Wuzzy (Crayola), whose RBG values are (204, 102, 102), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Fuzzy Wuzzy (Crayola), whose RBG values are (204, 102, 102), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color GO Green, whose RBG values are (0, 171, 102), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) gOGreenColor;
/*!
* Returns a UIColor object representing the color GO Green, whose RBG values are (0, 171, 102), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Gainsboro, whose RBG values are (220, 220, 220), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) gainsboroColor;
/*!
* Returns a UIColor object representing the color Gainsboro, whose RBG values are (220, 220, 220), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Gamboge, whose RBG values are (228, 155, 15), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) gambogeColor;
/*!
* Returns a UIColor object representing the color Gamboge, whose RBG values are (228, 155, 15), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Gamboge Orange (Brown), whose RBG values are (152, 102, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Gamboge Orange (Brown), whose RBG values are (152, 102, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Generic Viridian, whose RBG values are (0, 127, 102), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Generic Viridian, whose RBG values are (0, 127, 102), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ghost White, whose RBG values are (248, 248, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ghostWhiteColor;
/*!
* Returns a UIColor object representing the color Ghost White, whose RBG values are (248, 248, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Giants Orange, whose RBG values are (254, 90, 29), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) giantsOrangeColor;
/*!
* Returns a UIColor object representing the color Giants Orange, whose RBG values are (254, 90, 29), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Glaucous, whose RBG values are (96, 130, 182), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) glaucousColor;
/*!
* Returns a UIColor object representing the color Glaucous, whose RBG values are (96, 130, 182), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Glitter, whose RBG values are (230, 232, 250), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) glitterColor;
/*!
* Returns a UIColor object representing the color Glitter, whose RBG values are (230, 232, 250), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Gold (Crayola), whose RBG values are (231, 198, 151), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) goldCrayolaColor;
/*!
* Returns a UIColor object representing the color Gold (Crayola), whose RBG values are (231, 198, 151), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Gold (Metallic), whose RBG values are (212, 175, 55), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) goldMetallicColor;
/*!
* Returns a UIColor object representing the color Gold (Metallic), whose RBG values are (212, 175, 55), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Gold (Web) (Golden), whose RBG values are (255, 215, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) goldWebGoldenColor;
/*!
* Returns a UIColor object representing the color Gold (Web) (Golden), whose RBG values are (255, 215, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Gold Fusion, whose RBG values are (133, 117, 78), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) goldFusionColor;
/*!
* Returns a UIColor object representing the color Gold Fusion, whose RBG values are (133, 117, 78), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Golden Brown, whose RBG values are (153, 101, 21), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) goldenBrownColor;
/*!
* Returns a UIColor object representing the color Golden Brown, whose RBG values are (153, 101, 21), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Golden Poppy, whose RBG values are (252, 194, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) goldenPoppyColor;
/*!
* Returns a UIColor object representing the color Golden Poppy, whose RBG values are (252, 194, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Golden Yellow, whose RBG values are (255, 223, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) goldenYellowColor;
/*!
* Returns a UIColor object representing the color Golden Yellow, whose RBG values are (255, 223, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Goldenrod, whose RBG values are (218, 165, 32), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) goldenrodColor;
/*!
* Returns a UIColor object representing the color Goldenrod, whose RBG values are (218, 165, 32), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Goldenrod (Crayola), whose RBG values are (252, 217, 117), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Goldenrod (Crayola), whose RBG values are (252, 217, 117), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Granny Smith Apple (Crayola), whose RBG values are (168, 228, 160), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Granny Smith Apple (Crayola), whose RBG values are (168, 228, 160), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Grape, whose RBG values are (111, 45, 168), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) grapeColor;
/*!
* Returns a UIColor object representing the color Grape, whose RBG values are (111, 45, 168), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) grapeColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Gray (Alternate), whose RBG values are (128, 128, 128), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) grayAlternateColor;
/*!
* Returns a UIColor object representing the color Gray (Alternate), whose RBG values are (128, 128, 128), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Gray (Crayola), whose RBG values are (149, 145, 140), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) grayCrayolaColor;
/*!
* Returns a UIColor object representing the color Gray (Crayola), whose RBG values are (149, 145, 140), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Gray (HTML/CSS Gray), whose RBG values are (128, 128, 128), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Gray (HTML/CSS Gray), whose RBG values are (128, 128, 128), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Gray (X11 Gray), whose RBG values are (190, 190, 190), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) grayX11GrayColor;
/*!
* Returns a UIColor object representing the color Gray (X11 Gray), whose RBG values are (190, 190, 190), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Gray-Asparagus, whose RBG values are (70, 89, 69), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) grayAsparagusColor;
/*!
* Returns a UIColor object representing the color Gray-Asparagus, whose RBG values are (70, 89, 69), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Gray-Blue, whose RBG values are (140, 146, 172), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) grayBlueColor;
/*!
* Returns a UIColor object representing the color Gray-Blue, whose RBG values are (140, 146, 172), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green (Color Wheel) (X11 Green), whose RBG values are (0, 255, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Green (Color Wheel) (X11 Green), whose RBG values are (0, 255, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green (Crayola), whose RBG values are (28, 172, 120), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) greenCrayolaColor;
/*!
* Returns a UIColor object representing the color Green (Crayola), whose RBG values are (28, 172, 120), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green (HTML/CSS Color), whose RBG values are (0, 128, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) greenHTMLCSSColor;
/*!
* Returns a UIColor object representing the color Green (HTML/CSS Color), whose RBG values are (0, 128, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green (Munsell), whose RBG values are (0, 168, 119), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) greenMunsellColor;
/*!
* Returns a UIColor object representing the color Green (Munsell), whose RBG values are (0, 168, 119), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green (NCS), whose RBG values are (0, 159, 107), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) greenNCSColor;
/*!
* Returns a UIColor object representing the color Green (NCS), whose RBG values are (0, 159, 107), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green (Pantone), whose RBG values are (0, 173, 67), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) greenPantoneColor;
/*!
* Returns a UIColor object representing the color Green (Pantone), whose RBG values are (0, 173, 67), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green (Pigment), whose RBG values are (0, 165, 80), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) greenPigmentColor;
/*!
* Returns a UIColor object representing the color Green (Pigment), whose RBG values are (0, 165, 80), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green (RYB), whose RBG values are (102, 176, 50), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) greenRYBColor;
/*!
* Returns a UIColor object representing the color Green (RYB), whose RBG values are (102, 176, 50), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green 100, whose RBG values are (200, 230, 201), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) green100Color;
/*!
* Returns a UIColor object representing the color Green 100, whose RBG values are (200, 230, 201), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green 200, whose RBG values are (165, 214, 167), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) green200Color;
/*!
* Returns a UIColor object representing the color Green 200, whose RBG values are (165, 214, 167), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green 300, whose RBG values are (129, 199, 132), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) green300Color;
/*!
* Returns a UIColor object representing the color Green 300, whose RBG values are (129, 199, 132), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green 400, whose RBG values are (102, 187, 106), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) green400Color;
/*!
* Returns a UIColor object representing the color Green 400, whose RBG values are (102, 187, 106), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green 50, whose RBG values are (232, 245, 233), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) green50Color;
/*!
* Returns a UIColor object representing the color Green 50, whose RBG values are (232, 245, 233), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green 500, whose RBG values are (76, 175, 80), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) green500Color;
/*!
* Returns a UIColor object representing the color Green 500, whose RBG values are (76, 175, 80), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green 600, whose RBG values are (67, 160, 71), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) green600Color;
/*!
* Returns a UIColor object representing the color Green 600, whose RBG values are (67, 160, 71), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green 700, whose RBG values are (56, 142, 60), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) green700Color;
/*!
* Returns a UIColor object representing the color Green 700, whose RBG values are (56, 142, 60), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green 800, whose RBG values are (46, 125, 50), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) green800Color;
/*!
* Returns a UIColor object representing the color Green 800, whose RBG values are (46, 125, 50), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green 900, whose RBG values are (27, 94, 32), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) green900Color;
/*!
* Returns a UIColor object representing the color Green 900, whose RBG values are (27, 94, 32), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green A100, whose RBG values are (185, 246, 202), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) greenA100Color;
/*!
* Returns a UIColor object representing the color Green A100, whose RBG values are (185, 246, 202), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green A200, whose RBG values are (105, 240, 174), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) greenA200Color;
/*!
* Returns a UIColor object representing the color Green A200, whose RBG values are (105, 240, 174), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green A400, whose RBG values are (0, 230, 118), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) greenA400Color;
/*!
* Returns a UIColor object representing the color Green A400, whose RBG values are (0, 230, 118), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green A700, whose RBG values are (0, 200, 83), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) greenA700Color;
/*!
* Returns a UIColor object representing the color Green A700, whose RBG values are (0, 200, 83), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green Blue (Crayola), whose RBG values are (17, 100, 180), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Green Blue (Crayola), whose RBG values are (17, 100, 180), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green Yellow (Crayola), whose RBG values are (240, 232, 145), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Green Yellow (Crayola), whose RBG values are (240, 232, 145), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green Yellow, whose RBG values are (173, 255, 47), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) greenYellowColor;
/*!
* Returns a UIColor object representing the color Green Yellow, whose RBG values are (173, 255, 47), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Green-Cyan, whose RBG values are (0, 153, 102), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) greenCyanColor;
/*!
* Returns a UIColor object representing the color Green-Cyan, whose RBG values are (0, 153, 102), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Grey 100, whose RBG values are (245, 245, 245), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) grey100Color;
/*!
* Returns a UIColor object representing the color Grey 100, whose RBG values are (245, 245, 245), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Grey 200, whose RBG values are (238, 238, 238), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) grey200Color;
/*!
* Returns a UIColor object representing the color Grey 200, whose RBG values are (238, 238, 238), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Grey 300, whose RBG values are (224, 224, 224), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) grey300Color;
/*!
* Returns a UIColor object representing the color Grey 300, whose RBG values are (224, 224, 224), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Grey 400, whose RBG values are (189, 189, 189), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) grey400Color;
/*!
* Returns a UIColor object representing the color Grey 400, whose RBG values are (189, 189, 189), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Grey 50, whose RBG values are (250, 250, 250), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) grey50Color;
/*!
* Returns a UIColor object representing the color Grey 50, whose RBG values are (250, 250, 250), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Grey 500, whose RBG values are (158, 158, 158), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) grey500Color;
/*!
* Returns a UIColor object representing the color Grey 500, whose RBG values are (158, 158, 158), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Grey 600, whose RBG values are (117, 117, 117), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) grey600Color;
/*!
* Returns a UIColor object representing the color Grey 600, whose RBG values are (117, 117, 117), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Grey 700, whose RBG values are (97, 97, 97), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) grey700Color;
/*!
* Returns a UIColor object representing the color Grey 700, whose RBG values are (97, 97, 97), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Grey 800, whose RBG values are (66, 66, 66), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) grey800Color;
/*!
* Returns a UIColor object representing the color Grey 800, whose RBG values are (66, 66, 66), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Grey 900, whose RBG values are (33, 33, 33), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) grey900Color;
/*!
* Returns a UIColor object representing the color Grey 900, whose RBG values are (33, 33, 33), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Grizzly, whose RBG values are (136, 88, 24), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) grizzlyColor;
/*!
* Returns a UIColor object representing the color Grizzly, whose RBG values are (136, 88, 24), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Grullo, whose RBG values are (169, 154, 134), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) grulloColor;
/*!
* Returns a UIColor object representing the color Grullo, whose RBG values are (169, 154, 134), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Grussrel, whose RBG values are (176, 101, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) grussrelColor;
/*!
* Returns a UIColor object representing the color Grussrel, whose RBG values are (176, 101, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Gunmetal, whose RBG values are (42, 52, 57), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) gunmetalColor;
/*!
* Returns a UIColor object representing the color Gunmetal, whose RBG values are (42, 52, 57), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Guppie Green, whose RBG values are (0, 255, 127), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) guppieGreenColor;
/*!
* Returns a UIColor object representing the color Guppie Green, whose RBG values are (0, 255, 127), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
+ (UIColor *) halayàúbeColor;
+ (UIColor *) halayàúbeColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Han Blue, whose RBG values are (68, 108, 207), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) hanBlueColor;
/*!
* Returns a UIColor object representing the color Han Blue, whose RBG values are (68, 108, 207), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Han Purple, whose RBG values are (82, 24, 250), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) hanPurpleColor;
/*!
* Returns a UIColor object representing the color Han Purple, whose RBG values are (82, 24, 250), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Hansa Yellow, whose RBG values are (233, 214, 107), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) hansaYellowColor;
/*!
* Returns a UIColor object representing the color Hansa Yellow, whose RBG values are (233, 214, 107), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Harlequin, whose RBG values are (63, 255, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) harlequinColor;
/*!
* Returns a UIColor object representing the color Harlequin, whose RBG values are (63, 255, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Harlequin Green, whose RBG values are (70, 203, 24), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) harlequinGreenColor;
/*!
* Returns a UIColor object representing the color Harlequin Green, whose RBG values are (70, 203, 24), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Harvard Crimson, whose RBG values are (201, 0, 22), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) harvardCrimsonColor;
/*!
* Returns a UIColor object representing the color Harvard Crimson, whose RBG values are (201, 0, 22), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Harvest Gold, whose RBG values are (218, 145, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) harvestGoldColor;
/*!
* Returns a UIColor object representing the color Harvest Gold, whose RBG values are (218, 145, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Heart Gold, whose RBG values are (128, 128, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) heartGoldColor;
/*!
* Returns a UIColor object representing the color Heart Gold, whose RBG values are (128, 128, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Heliotrope, whose RBG values are (223, 115, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) heliotropeColor;
/*!
* Returns a UIColor object representing the color Heliotrope, whose RBG values are (223, 115, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Heliotrope Gray, whose RBG values are (170, 152, 168), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) heliotropeGrayColor;
/*!
* Returns a UIColor object representing the color Heliotrope Gray, whose RBG values are (170, 152, 168), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Heliotrope Magenta, whose RBG values are (170, 0, 187), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Heliotrope Magenta, whose RBG values are (170, 0, 187), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Hollywood Cerise, whose RBG values are (244, 0, 161), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Hollywood Cerise, whose RBG values are (244, 0, 161), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Honeydew, whose RBG values are (240, 255, 240), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) honeydewColor;
/*!
* Returns a UIColor object representing the color Honeydew, whose RBG values are (240, 255, 240), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Honolulu Blue, whose RBG values are (0, 109, 176), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) honoluluBlueColor;
/*!
* Returns a UIColor object representing the color Honolulu Blue, whose RBG values are (0, 109, 176), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Hooker's Green, whose RBG values are (73, 121, 107), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) hookersGreenColor;
/*!
* Returns a UIColor object representing the color Hooker's Green, whose RBG values are (73, 121, 107), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Hot Magenta (Crayola), whose RBG values are (255, 29, 206), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Hot Magenta (Crayola), whose RBG values are (255, 29, 206), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Hot Pink, whose RBG values are (255, 105, 180), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) hotPinkColor;
/*!
* Returns a UIColor object representing the color Hot Pink, whose RBG values are (255, 105, 180), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Hunter Green, whose RBG values are (53, 94, 59), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) hunterGreenColor;
/*!
* Returns a UIColor object representing the color Hunter Green, whose RBG values are (53, 94, 59), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Iceberg, whose RBG values are (113, 166, 210), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) icebergColor;
/*!
* Returns a UIColor object representing the color Iceberg, whose RBG values are (113, 166, 210), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Icterine, whose RBG values are (252, 247, 94), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) icterineColor;
/*!
* Returns a UIColor object representing the color Icterine, whose RBG values are (252, 247, 94), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Illuminating Emerald, whose RBG values are (49, 145, 119), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Illuminating Emerald, whose RBG values are (49, 145, 119), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Imperial, whose RBG values are (96, 47, 107), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) imperialColor;
/*!
* Returns a UIColor object representing the color Imperial, whose RBG values are (96, 47, 107), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Imperial Blue, whose RBG values are (0, 35, 149), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) imperialBlueColor;
/*!
* Returns a UIColor object representing the color Imperial Blue, whose RBG values are (0, 35, 149), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Imperial Purple, whose RBG values are (102, 2, 60), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) imperialPurpleColor;
/*!
* Returns a UIColor object representing the color Imperial Purple, whose RBG values are (102, 2, 60), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Imperial Red, whose RBG values are (237, 41, 57), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) imperialRedColor;
/*!
* Returns a UIColor object representing the color Imperial Red, whose RBG values are (237, 41, 57), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Inchworm (Crayola), whose RBG values are (178, 236, 93), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Inchworm (Crayola), whose RBG values are (178, 236, 93), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Independence, whose RBG values are (76, 81, 109), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) independenceColor;
/*!
* Returns a UIColor object representing the color Independence, whose RBG values are (76, 81, 109), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color India Green, whose RBG values are (19, 136, 8), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) indiaGreenColor;
/*!
* Returns a UIColor object representing the color India Green, whose RBG values are (19, 136, 8), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Indian Red, whose RBG values are (205, 92, 92), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) indianRedColor;
/*!
* Returns a UIColor object representing the color Indian Red, whose RBG values are (205, 92, 92), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Indian Yellow, whose RBG values are (227, 168, 87), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) indianYellowColor;
/*!
* Returns a UIColor object representing the color Indian Yellow, whose RBG values are (227, 168, 87), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Indigo, whose RBG values are (75, 0, 130), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) indigoColor;
/*!
* Returns a UIColor object representing the color Indigo, whose RBG values are (75, 0, 130), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Indigo (Crayola), whose RBG values are (93, 118, 203), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) indigoCrayolaColor;
/*!
* Returns a UIColor object representing the color Indigo (Crayola), whose RBG values are (93, 118, 203), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Indigo 100, whose RBG values are (197, 202, 233), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) indigo100Color;
/*!
* Returns a UIColor object representing the color Indigo 100, whose RBG values are (197, 202, 233), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Indigo 200, whose RBG values are (159, 168, 218), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) indigo200Color;
/*!
* Returns a UIColor object representing the color Indigo 200, whose RBG values are (159, 168, 218), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Indigo 300, whose RBG values are (121, 134, 203), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) indigo300Color;
/*!
* Returns a UIColor object representing the color Indigo 300, whose RBG values are (121, 134, 203), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Indigo 400, whose RBG values are (92, 107, 192), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) indigo400Color;
/*!
* Returns a UIColor object representing the color Indigo 400, whose RBG values are (92, 107, 192), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Indigo 50, whose RBG values are (232, 234, 246), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) indigo50Color;
/*!
* Returns a UIColor object representing the color Indigo 50, whose RBG values are (232, 234, 246), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Indigo 500, whose RBG values are (63, 81, 181), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) indigo500Color;
/*!
* Returns a UIColor object representing the color Indigo 500, whose RBG values are (63, 81, 181), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Indigo 600, whose RBG values are (57, 73, 171), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) indigo600Color;
/*!
* Returns a UIColor object representing the color Indigo 600, whose RBG values are (57, 73, 171), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Indigo 700, whose RBG values are (48, 63, 159), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) indigo700Color;
/*!
* Returns a UIColor object representing the color Indigo 700, whose RBG values are (48, 63, 159), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Indigo 800, whose RBG values are (40, 53, 147), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) indigo800Color;
/*!
* Returns a UIColor object representing the color Indigo 800, whose RBG values are (40, 53, 147), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Indigo 900, whose RBG values are (26, 35, 126), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) indigo900Color;
/*!
* Returns a UIColor object representing the color Indigo 900, whose RBG values are (26, 35, 126), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Indigo A100, whose RBG values are (140, 158, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) indigoA100Color;
/*!
* Returns a UIColor object representing the color Indigo A100, whose RBG values are (140, 158, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Indigo A200, whose RBG values are (83, 109, 254), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) indigoA200Color;
/*!
* Returns a UIColor object representing the color Indigo A200, whose RBG values are (83, 109, 254), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Indigo A400, whose RBG values are (61, 90, 254), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) indigoA400Color;
/*!
* Returns a UIColor object representing the color Indigo A400, whose RBG values are (61, 90, 254), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Indigo A700, whose RBG values are (48, 79, 254), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) indigoA700Color;
/*!
* Returns a UIColor object representing the color Indigo A700, whose RBG values are (48, 79, 254), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Indigo Dye, whose RBG values are (9, 31, 146), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) indigoDyeColor;
/*!
* Returns a UIColor object representing the color Indigo Dye, whose RBG values are (9, 31, 146), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color International Klein Blue, whose RBG values are (0, 47, 167), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color International Klein Blue, whose RBG values are (0, 47, 167), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color International Orange (Aerospace), whose RBG values are (255, 79, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color International Orange (Aerospace), whose RBG values are (255, 79, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color International Orange (Engineering), whose RBG values are (186, 22, 12), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color International Orange (Engineering), whose RBG values are (186, 22, 12), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color International Orange (Golden Gate Bridge), whose RBG values are (192, 54, 44), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color International Orange (Golden Gate Bridge), whose RBG values are (192, 54, 44), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Iris, whose RBG values are (90, 79, 207), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) irisColor;
/*!
* Returns a UIColor object representing the color Iris, whose RBG values are (90, 79, 207), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) irisColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Irresistible, whose RBG values are (179, 68, 108), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) irresistibleColor;
/*!
* Returns a UIColor object representing the color Irresistible, whose RBG values are (179, 68, 108), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Isabelline, whose RBG values are (244, 240, 236), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) isabellineColor;
/*!
* Returns a UIColor object representing the color Isabelline, whose RBG values are (244, 240, 236), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Islamic Green, whose RBG values are (0, 144, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) islamicGreenColor;
/*!
* Returns a UIColor object representing the color Islamic Green, whose RBG values are (0, 144, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Italian Sky Blue, whose RBG values are (178, 255, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) italianSkyBlueColor;
/*!
* Returns a UIColor object representing the color Italian Sky Blue, whose RBG values are (178, 255, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ivory, whose RBG values are (255, 255, 240), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ivoryColor;
/*!
* Returns a UIColor object representing the color Ivory, whose RBG values are (255, 255, 240), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ivoryColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Jade, whose RBG values are (0, 168, 107), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) jadeColor;
/*!
* Returns a UIColor object representing the color Jade, whose RBG values are (0, 168, 107), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) jadeColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Japanese Carmine, whose RBG values are (157, 41, 51), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Japanese Carmine, whose RBG values are (157, 41, 51), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Japanese Indigo, whose RBG values are (38, 67, 72), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) japaneseIndigoColor;
/*!
* Returns a UIColor object representing the color Japanese Indigo, whose RBG values are (38, 67, 72), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Japanese Violet, whose RBG values are (91, 50, 86), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) japaneseVioletColor;
/*!
* Returns a UIColor object representing the color Japanese Violet, whose RBG values are (91, 50, 86), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Jasmine, whose RBG values are (248, 222, 126), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) jasmineColor;
/*!
* Returns a UIColor object representing the color Jasmine, whose RBG values are (248, 222, 126), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Jasper, whose RBG values are (215, 59, 62), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) jasperColor;
/*!
* Returns a UIColor object representing the color Jasper, whose RBG values are (215, 59, 62), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Jawad/Chicken Color (HTML/CSS) (Khaki), whose RBG values are (195, 176, 145), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Jawad/Chicken Color (HTML/CSS) (Khaki), whose RBG values are (195, 176, 145), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Jazzberry Jam (Crayola), whose RBG values are (202, 55, 103), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Jazzberry Jam (Crayola), whose RBG values are (202, 55, 103), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Jelly Bean, whose RBG values are (218, 97, 78), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) jellyBeanColor;
/*!
* Returns a UIColor object representing the color Jelly Bean, whose RBG values are (218, 97, 78), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Jet, whose RBG values are (52, 52, 52), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) jetColor;
/*!
* Returns a UIColor object representing the color Jet, whose RBG values are (52, 52, 52), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) jetColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Jonquil, whose RBG values are (244, 202, 22), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) jonquilColor;
/*!
* Returns a UIColor object representing the color Jonquil, whose RBG values are (244, 202, 22), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Jordy Blue, whose RBG values are (138, 185, 241), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) jordyBlueColor;
/*!
* Returns a UIColor object representing the color Jordy Blue, whose RBG values are (138, 185, 241), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color June Bud, whose RBG values are (189, 218, 87), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) juneBudColor;
/*!
* Returns a UIColor object representing the color June Bud, whose RBG values are (189, 218, 87), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Jungle Green (Crayola), whose RBG values are (59, 176, 143), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Jungle Green (Crayola), whose RBG values are (59, 176, 143), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color KU Crimson, whose RBG values are (232, 0, 13), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) kUCrimsonColor;
/*!
* Returns a UIColor object representing the color KU Crimson, whose RBG values are (232, 0, 13), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Kelly Green, whose RBG values are (76, 187, 23), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) kellyGreenColor;
/*!
* Returns a UIColor object representing the color Kelly Green, whose RBG values are (76, 187, 23), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Kenyan Copper, whose RBG values are (124, 28, 5), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) kenyanCopperColor;
/*!
* Returns a UIColor object representing the color Kenyan Copper, whose RBG values are (124, 28, 5), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Keppel, whose RBG values are (58, 176, 158), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) keppelColor;
/*!
* Returns a UIColor object representing the color Keppel, whose RBG values are (58, 176, 158), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Khaki, whose RBG values are (189, 183, 107), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) khakiColor;
/*!
* Returns a UIColor object representing the color Khaki, whose RBG values are (189, 183, 107), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) khakiColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Khaki (X11) (Light Khaki), whose RBG values are (240, 230, 140), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Khaki (X11) (Light Khaki), whose RBG values are (240, 230, 140), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Kobe, whose RBG values are (136, 45, 23), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) kobeColor;
/*!
* Returns a UIColor object representing the color Kobe, whose RBG values are (136, 45, 23), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) kobeColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Kobi, whose RBG values are (231, 159, 196), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) kobiColor;
/*!
* Returns a UIColor object representing the color Kobi, whose RBG values are (231, 159, 196), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) kobiColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Kombu Green, whose RBG values are (53, 66, 48), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) kombuGreenColor;
/*!
* Returns a UIColor object representing the color Kombu Green, whose RBG values are (53, 66, 48), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color La Salle Green, whose RBG values are (8, 120, 48), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) laSalleGreenColor;
/*!
* Returns a UIColor object representing the color La Salle Green, whose RBG values are (8, 120, 48), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Languid Lavender, whose RBG values are (214, 202, 221), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Languid Lavender, whose RBG values are (214, 202, 221), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lapis Lazuli, whose RBG values are (38, 97, 156), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lapisLazuliColor;
/*!
* Returns a UIColor object representing the color Lapis Lazuli, whose RBG values are (38, 97, 156), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Laser Lemon (Crayola), whose RBG values are (254, 254, 34), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Laser Lemon (Crayola), whose RBG values are (254, 254, 34), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Laurel Green, whose RBG values are (169, 186, 157), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) laurelGreenColor;
/*!
* Returns a UIColor object representing the color Laurel Green, whose RBG values are (169, 186, 157), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lava, whose RBG values are (207, 16, 32), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lavaColor;
/*!
* Returns a UIColor object representing the color Lava, whose RBG values are (207, 16, 32), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lavaColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lavender (Crayola), whose RBG values are (252, 180, 213), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Lavender (Crayola), whose RBG values are (252, 180, 213), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lavender (Floral), whose RBG values are (181, 126, 220), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lavenderFloralColor;
/*!
* Returns a UIColor object representing the color Lavender (Floral), whose RBG values are (181, 126, 220), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lavender (Web), whose RBG values are (230, 230, 250), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lavenderWebColor;
/*!
* Returns a UIColor object representing the color Lavender (Web), whose RBG values are (230, 230, 250), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lavender Blue, whose RBG values are (204, 204, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lavenderBlueColor;
/*!
* Returns a UIColor object representing the color Lavender Blue, whose RBG values are (204, 204, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lavender Blush, whose RBG values are (255, 240, 245), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lavenderBlushColor;
/*!
* Returns a UIColor object representing the color Lavender Blush, whose RBG values are (255, 240, 245), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lavender Gray, whose RBG values are (196, 195, 208), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lavenderGrayColor;
/*!
* Returns a UIColor object representing the color Lavender Gray, whose RBG values are (196, 195, 208), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lavender Indigo, whose RBG values are (148, 87, 235), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lavenderIndigoColor;
/*!
* Returns a UIColor object representing the color Lavender Indigo, whose RBG values are (148, 87, 235), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lavender Magenta, whose RBG values are (238, 130, 238), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Lavender Magenta, whose RBG values are (238, 130, 238), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lavender Mist, whose RBG values are (230, 230, 250), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lavenderMistColor;
/*!
* Returns a UIColor object representing the color Lavender Mist, whose RBG values are (230, 230, 250), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lavender Pink, whose RBG values are (251, 174, 210), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lavenderPinkColor;
/*!
* Returns a UIColor object representing the color Lavender Pink, whose RBG values are (251, 174, 210), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lavender Purple, whose RBG values are (150, 123, 182), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lavenderPurpleColor;
/*!
* Returns a UIColor object representing the color Lavender Purple, whose RBG values are (150, 123, 182), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lavender Rose, whose RBG values are (251, 160, 227), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lavenderRoseColor;
/*!
* Returns a UIColor object representing the color Lavender Rose, whose RBG values are (251, 160, 227), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lawn Green, whose RBG values are (124, 252, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lawnGreenColor;
/*!
* Returns a UIColor object representing the color Lawn Green, whose RBG values are (124, 252, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lemon, whose RBG values are (255, 247, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lemonColor;
/*!
* Returns a UIColor object representing the color Lemon, whose RBG values are (255, 247, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lemonColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lemon Yellow (Crayola), whose RBG values are (255, 244, 79), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Lemon Yellow (Crayola), whose RBG values are (255, 244, 79), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lemon Chiffon, whose RBG values are (255, 250, 205), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lemonChiffonColor;
/*!
* Returns a UIColor object representing the color Lemon Chiffon, whose RBG values are (255, 250, 205), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lemon Curry, whose RBG values are (204, 160, 29), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lemonCurryColor;
/*!
* Returns a UIColor object representing the color Lemon Curry, whose RBG values are (204, 160, 29), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lemon Glacier, whose RBG values are (253, 255, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lemonGlacierColor;
/*!
* Returns a UIColor object representing the color Lemon Glacier, whose RBG values are (253, 255, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lemon Lime, whose RBG values are (227, 255, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lemonLimeColor;
/*!
* Returns a UIColor object representing the color Lemon Lime, whose RBG values are (227, 255, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lemon Meringue, whose RBG values are (246, 234, 190), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lemonMeringueColor;
/*!
* Returns a UIColor object representing the color Lemon Meringue, whose RBG values are (246, 234, 190), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lenurple, whose RBG values are (186, 147, 216), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lenurpleColor;
/*!
* Returns a UIColor object representing the color Lenurple, whose RBG values are (186, 147, 216), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Liberty, whose RBG values are (84, 90, 167), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) libertyColor;
/*!
* Returns a UIColor object representing the color Liberty, whose RBG values are (84, 90, 167), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Licorice, whose RBG values are (26, 17, 16), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) licoriceColor;
/*!
* Returns a UIColor object representing the color Licorice, whose RBG values are (26, 17, 16), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Blue (Crayola), whose RBG values are (173, 216, 230), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Light Blue (Crayola), whose RBG values are (173, 216, 230), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Blue 100, whose RBG values are (179, 229, 252), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightBlue100Color;
/*!
* Returns a UIColor object representing the color Light Blue 100, whose RBG values are (179, 229, 252), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Blue 200, whose RBG values are (129, 212, 250), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightBlue200Color;
/*!
* Returns a UIColor object representing the color Light Blue 200, whose RBG values are (129, 212, 250), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Blue 300, whose RBG values are (79, 195, 247), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightBlue300Color;
/*!
* Returns a UIColor object representing the color Light Blue 300, whose RBG values are (79, 195, 247), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Blue 400, whose RBG values are (41, 182, 246), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightBlue400Color;
/*!
* Returns a UIColor object representing the color Light Blue 400, whose RBG values are (41, 182, 246), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Blue 50, whose RBG values are (225, 245, 254), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightBlue50Color;
/*!
* Returns a UIColor object representing the color Light Blue 50, whose RBG values are (225, 245, 254), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Blue 500, whose RBG values are (3, 169, 244), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightBlue500Color;
/*!
* Returns a UIColor object representing the color Light Blue 500, whose RBG values are (3, 169, 244), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Blue 600, whose RBG values are (3, 155, 229), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightBlue600Color;
/*!
* Returns a UIColor object representing the color Light Blue 600, whose RBG values are (3, 155, 229), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Blue 700, whose RBG values are (2, 136, 209), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightBlue700Color;
/*!
* Returns a UIColor object representing the color Light Blue 700, whose RBG values are (2, 136, 209), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Blue 800, whose RBG values are (2, 119, 189), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightBlue800Color;
/*!
* Returns a UIColor object representing the color Light Blue 800, whose RBG values are (2, 119, 189), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Blue 900, whose RBG values are (1, 87, 155), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightBlue900Color;
/*!
* Returns a UIColor object representing the color Light Blue 900, whose RBG values are (1, 87, 155), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Blue A100, whose RBG values are (128, 216, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightBlueA100Color;
/*!
* Returns a UIColor object representing the color Light Blue A100, whose RBG values are (128, 216, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Blue A200, whose RBG values are (64, 196, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightBlueA200Color;
/*!
* Returns a UIColor object representing the color Light Blue A200, whose RBG values are (64, 196, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Blue A400, whose RBG values are (0, 176, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightBlueA400Color;
/*!
* Returns a UIColor object representing the color Light Blue A400, whose RBG values are (0, 176, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Blue A700, whose RBG values are (0, 145, 234), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightBlueA700Color;
/*!
* Returns a UIColor object representing the color Light Blue A700, whose RBG values are (0, 145, 234), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light French Beige, whose RBG values are (200, 173, 127), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Light French Beige, whose RBG values are (200, 173, 127), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Green 100, whose RBG values are (220, 237, 200), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightGreen100Color;
/*!
* Returns a UIColor object representing the color Light Green 100, whose RBG values are (220, 237, 200), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Green 200, whose RBG values are (197, 225, 165), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightGreen200Color;
/*!
* Returns a UIColor object representing the color Light Green 200, whose RBG values are (197, 225, 165), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Green 300, whose RBG values are (174, 213, 129), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightGreen300Color;
/*!
* Returns a UIColor object representing the color Light Green 300, whose RBG values are (174, 213, 129), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Green 400, whose RBG values are (156, 204, 101), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightGreen400Color;
/*!
* Returns a UIColor object representing the color Light Green 400, whose RBG values are (156, 204, 101), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Green 50, whose RBG values are (241, 248, 233), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightGreen50Color;
/*!
* Returns a UIColor object representing the color Light Green 50, whose RBG values are (241, 248, 233), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Green 500, whose RBG values are (139, 195, 74), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightGreen500Color;
/*!
* Returns a UIColor object representing the color Light Green 500, whose RBG values are (139, 195, 74), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Green 600, whose RBG values are (124, 179, 66), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightGreen600Color;
/*!
* Returns a UIColor object representing the color Light Green 600, whose RBG values are (124, 179, 66), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Green 700, whose RBG values are (104, 159, 56), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightGreen700Color;
/*!
* Returns a UIColor object representing the color Light Green 700, whose RBG values are (104, 159, 56), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Green 800, whose RBG values are (85, 139, 47), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightGreen800Color;
/*!
* Returns a UIColor object representing the color Light Green 800, whose RBG values are (85, 139, 47), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Green 900, whose RBG values are (51, 105, 30), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightGreen900Color;
/*!
* Returns a UIColor object representing the color Light Green 900, whose RBG values are (51, 105, 30), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Green A100, whose RBG values are (204, 255, 144), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightGreenA100Color;
/*!
* Returns a UIColor object representing the color Light Green A100, whose RBG values are (204, 255, 144), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Green A200, whose RBG values are (178, 255, 89), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightGreenA200Color;
/*!
* Returns a UIColor object representing the color Light Green A200, whose RBG values are (178, 255, 89), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Green A400, whose RBG values are (118, 255, 3), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightGreenA400Color;
/*!
* Returns a UIColor object representing the color Light Green A400, whose RBG values are (118, 255, 3), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Green A700, whose RBG values are (100, 221, 23), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightGreenA700Color;
/*!
* Returns a UIColor object representing the color Light Green A700, whose RBG values are (100, 221, 23), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Thulian Pink, whose RBG values are (230, 143, 172), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Light Thulian Pink, whose RBG values are (230, 143, 172), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Apricot, whose RBG values are (253, 213, 177), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightApricotColor;
/*!
* Returns a UIColor object representing the color Light Apricot, whose RBG values are (253, 213, 177), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Blue, whose RBG values are (173, 216, 230), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightBlueColor;
/*!
* Returns a UIColor object representing the color Light Blue, whose RBG values are (173, 216, 230), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Brilliant Red, whose RBG values are (254, 46, 46), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Light Brilliant Red, whose RBG values are (254, 46, 46), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Brown, whose RBG values are (181, 101, 29), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightBrownColor;
/*!
* Returns a UIColor object representing the color Light Brown, whose RBG values are (181, 101, 29), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Carmine Pink, whose RBG values are (230, 103, 113), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Light Carmine Pink, whose RBG values are (230, 103, 113), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Cobalt Blue, whose RBG values are (136, 172, 224), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Light Cobalt Blue, whose RBG values are (136, 172, 224), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Coral, whose RBG values are (240, 128, 128), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightCoralColor;
/*!
* Returns a UIColor object representing the color Light Coral, whose RBG values are (240, 128, 128), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Cornflower Blue, whose RBG values are (147, 204, 234), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Light Cornflower Blue, whose RBG values are (147, 204, 234), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Crimson, whose RBG values are (245, 105, 145), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightCrimsonColor;
/*!
* Returns a UIColor object representing the color Light Crimson, whose RBG values are (245, 105, 145), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Cyan, whose RBG values are (224, 255, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightCyanColor;
/*!
* Returns a UIColor object representing the color Light Cyan, whose RBG values are (224, 255, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Deep Pink, whose RBG values are (255, 92, 205), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightDeepPinkColor;
/*!
* Returns a UIColor object representing the color Light Deep Pink, whose RBG values are (255, 92, 205), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Fuchsia Pink, whose RBG values are (249, 132, 239), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Light Fuchsia Pink, whose RBG values are (249, 132, 239), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Goldenrod Yellow, whose RBG values are (250, 250, 210), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Light Goldenrod Yellow, whose RBG values are (250, 250, 210), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Gray (Alternate), whose RBG values are (211, 211, 211), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Light Gray (Alternate), whose RBG values are (211, 211, 211), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Grayish Magenta, whose RBG values are (204, 153, 204), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Light Grayish Magenta, whose RBG values are (204, 153, 204), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Green, whose RBG values are (144, 238, 144), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightGreenColor;
/*!
* Returns a UIColor object representing the color Light Green, whose RBG values are (144, 238, 144), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Hot Pink, whose RBG values are (255, 179, 222), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightHotPinkColor;
/*!
* Returns a UIColor object representing the color Light Hot Pink, whose RBG values are (255, 179, 222), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Khaki, whose RBG values are (240, 230, 140), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightKhakiColor;
/*!
* Returns a UIColor object representing the color Light Khaki, whose RBG values are (240, 230, 140), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Medium Orchid, whose RBG values are (211, 155, 203), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Light Medium Orchid, whose RBG values are (211, 155, 203), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Moss Green, whose RBG values are (173, 223, 173), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightMossGreenColor;
/*!
* Returns a UIColor object representing the color Light Moss Green, whose RBG values are (173, 223, 173), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Orchid, whose RBG values are (230, 168, 215), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightOrchidColor;
/*!
* Returns a UIColor object representing the color Light Orchid, whose RBG values are (230, 168, 215), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Pastel Purple, whose RBG values are (177, 156, 217), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Light Pastel Purple, whose RBG values are (177, 156, 217), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Pink, whose RBG values are (255, 182, 193), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightPinkColor;
/*!
* Returns a UIColor object representing the color Light Pink, whose RBG values are (255, 182, 193), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Red Ochre, whose RBG values are (233, 116, 81), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightRedOchreColor;
/*!
* Returns a UIColor object representing the color Light Red Ochre, whose RBG values are (233, 116, 81), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Salmon, whose RBG values are (255, 160, 122), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightSalmonColor;
/*!
* Returns a UIColor object representing the color Light Salmon, whose RBG values are (255, 160, 122), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Salmon Pink, whose RBG values are (255, 153, 153), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Light Salmon Pink, whose RBG values are (255, 153, 153), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Sea Green, whose RBG values are (32, 178, 170), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightSeaGreenColor;
/*!
* Returns a UIColor object representing the color Light Sea Green, whose RBG values are (32, 178, 170), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Sky Blue, whose RBG values are (135, 206, 250), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightSkyBlueColor;
/*!
* Returns a UIColor object representing the color Light Sky Blue, whose RBG values are (135, 206, 250), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Slate Gray, whose RBG values are (119, 136, 153), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightSlateGrayColor;
/*!
* Returns a UIColor object representing the color Light Slate Gray, whose RBG values are (119, 136, 153), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Steel Blue, whose RBG values are (176, 196, 222), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightSteelBlueColor;
/*!
* Returns a UIColor object representing the color Light Steel Blue, whose RBG values are (176, 196, 222), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Taupe, whose RBG values are (179, 139, 109), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightTaupeColor;
/*!
* Returns a UIColor object representing the color Light Taupe, whose RBG values are (179, 139, 109), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Light Yellow, whose RBG values are (255, 255, 224), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lightYellowColor;
/*!
* Returns a UIColor object representing the color Light Yellow, whose RBG values are (255, 255, 224), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lilac, whose RBG values are (200, 162, 200), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lilacColor;
/*!
* Returns a UIColor object representing the color Lilac, whose RBG values are (200, 162, 200), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lilacColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lime (Color Wheel), whose RBG values are (191, 255, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) limeColorWheelColor;
/*!
* Returns a UIColor object representing the color Lime (Color Wheel), whose RBG values are (191, 255, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lime (Web) (X11 Green), whose RBG values are (0, 255, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Lime (Web) (X11 Green), whose RBG values are (0, 255, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lime 100, whose RBG values are (240, 244, 195), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lime100Color;
/*!
* Returns a UIColor object representing the color Lime 100, whose RBG values are (240, 244, 195), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lime 200, whose RBG values are (230, 238, 156), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lime200Color;
/*!
* Returns a UIColor object representing the color Lime 200, whose RBG values are (230, 238, 156), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lime 300, whose RBG values are (220, 231, 117), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lime300Color;
/*!
* Returns a UIColor object representing the color Lime 300, whose RBG values are (220, 231, 117), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lime 400, whose RBG values are (212, 225, 87), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lime400Color;
/*!
* Returns a UIColor object representing the color Lime 400, whose RBG values are (212, 225, 87), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lime 50, whose RBG values are (249, 251, 231), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lime50Color;
/*!
* Returns a UIColor object representing the color Lime 50, whose RBG values are (249, 251, 231), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lime 500, whose RBG values are (205, 220, 57), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lime500Color;
/*!
* Returns a UIColor object representing the color Lime 500, whose RBG values are (205, 220, 57), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lime 600, whose RBG values are (192, 202, 51), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lime600Color;
/*!
* Returns a UIColor object representing the color Lime 600, whose RBG values are (192, 202, 51), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lime 700, whose RBG values are (175, 180, 43), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lime700Color;
/*!
* Returns a UIColor object representing the color Lime 700, whose RBG values are (175, 180, 43), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lime 800, whose RBG values are (158, 157, 36), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lime800Color;
/*!
* Returns a UIColor object representing the color Lime 800, whose RBG values are (158, 157, 36), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lime 900, whose RBG values are (130, 119, 23), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lime900Color;
/*!
* Returns a UIColor object representing the color Lime 900, whose RBG values are (130, 119, 23), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lime A100, whose RBG values are (244, 255, 129), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) limeA100Color;
/*!
* Returns a UIColor object representing the color Lime A100, whose RBG values are (244, 255, 129), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lime A200, whose RBG values are (238, 255, 65), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) limeA200Color;
/*!
* Returns a UIColor object representing the color Lime A200, whose RBG values are (238, 255, 65), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lime A400, whose RBG values are (198, 255, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) limeA400Color;
/*!
* Returns a UIColor object representing the color Lime A400, whose RBG values are (198, 255, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lime A700, whose RBG values are (174, 234, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) limeA700Color;
/*!
* Returns a UIColor object representing the color Lime A700, whose RBG values are (174, 234, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lime Green, whose RBG values are (50, 205, 50), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) limeGreenColor;
/*!
* Returns a UIColor object representing the color Lime Green, whose RBG values are (50, 205, 50), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Limerick, whose RBG values are (157, 194, 9), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) limerickColor;
/*!
* Returns a UIColor object representing the color Limerick, whose RBG values are (157, 194, 9), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lincoln Green, whose RBG values are (25, 89, 5), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lincolnGreenColor;
/*!
* Returns a UIColor object representing the color Lincoln Green, whose RBG values are (25, 89, 5), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Linen, whose RBG values are (250, 240, 230), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) linenColor;
/*!
* Returns a UIColor object representing the color Linen, whose RBG values are (250, 240, 230), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) linenColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lion, whose RBG values are (193, 154, 107), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lionColor;
/*!
* Returns a UIColor object representing the color Lion, whose RBG values are (193, 154, 107), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lionColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Liseran Purple, whose RBG values are (222, 111, 161), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) liseranPurpleColor;
/*!
* Returns a UIColor object representing the color Liseran Purple, whose RBG values are (222, 111, 161), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Little Boy Blue, whose RBG values are (108, 160, 220), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) littleBoyBlueColor;
/*!
* Returns a UIColor object representing the color Little Boy Blue, whose RBG values are (108, 160, 220), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Liver, whose RBG values are (103, 76, 71), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) liverColor;
/*!
* Returns a UIColor object representing the color Liver, whose RBG values are (103, 76, 71), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) liverColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Liver (Dogs), whose RBG values are (184, 109, 41), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) liverDogsColor;
/*!
* Returns a UIColor object representing the color Liver (Dogs), whose RBG values are (184, 109, 41), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Liver (Organ), whose RBG values are (108, 46, 31), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) liverOrganColor;
/*!
* Returns a UIColor object representing the color Liver (Organ), whose RBG values are (108, 46, 31), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Liver Chestnut, whose RBG values are (152, 116, 86), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) liverChestnutColor;
/*!
* Returns a UIColor object representing the color Liver Chestnut, whose RBG values are (152, 116, 86), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Livid, whose RBG values are (102, 153, 204), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lividColor;
/*!
* Returns a UIColor object representing the color Livid, whose RBG values are (102, 153, 204), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lividColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lumber, whose RBG values are (255, 228, 205), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lumberColor;
/*!
* Returns a UIColor object representing the color Lumber, whose RBG values are (255, 228, 205), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Lust, whose RBG values are (230, 32, 32), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lustColor;
/*!
* Returns a UIColor object representing the color Lust, whose RBG values are (230, 32, 32), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) lustColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color MSU Green, whose RBG values are (24, 69, 59), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mSUGreenColor;
/*!
* Returns a UIColor object representing the color MSU Green, whose RBG values are (24, 69, 59), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Macaroni And Cheese (Crayola), whose RBG values are (255, 189, 136), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Macaroni And Cheese (Crayola), whose RBG values are (255, 189, 136), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Magenta (Crayola), whose RBG values are (246, 100, 175), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) magentaCrayolaColor;
/*!
* Returns a UIColor object representing the color Magenta (Crayola), whose RBG values are (246, 100, 175), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Magenta (Dye), whose RBG values are (202, 31, 123), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) magentaDyeColor;
/*!
* Returns a UIColor object representing the color Magenta (Dye), whose RBG values are (202, 31, 123), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Magenta (Pantone), whose RBG values are (208, 65, 126), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) magentaPantoneColor;
/*!
* Returns a UIColor object representing the color Magenta (Pantone), whose RBG values are (208, 65, 126), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Magenta (Process), whose RBG values are (255, 0, 144), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) magentaProcessColor;
/*!
* Returns a UIColor object representing the color Magenta (Process), whose RBG values are (255, 0, 144), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Magenta Haze, whose RBG values are (159, 69, 118), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) magentaHazeColor;
/*!
* Returns a UIColor object representing the color Magenta Haze, whose RBG values are (159, 69, 118), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Magenta-Pink, whose RBG values are (204, 51, 139), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) magentaPinkColor;
/*!
* Returns a UIColor object representing the color Magenta-Pink, whose RBG values are (204, 51, 139), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Magic Mint (Crayola), whose RBG values are (170, 240, 209), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Magic Mint (Crayola), whose RBG values are (170, 240, 209), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Magnolia, whose RBG values are (248, 244, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) magnoliaColor;
/*!
* Returns a UIColor object representing the color Magnolia, whose RBG values are (248, 244, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mahogany, whose RBG values are (192, 64, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mahoganyColor;
/*!
* Returns a UIColor object representing the color Mahogany, whose RBG values are (192, 64, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mahogany (Crayola), whose RBG values are (205, 74, 76), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Mahogany (Crayola), whose RBG values are (205, 74, 76), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Maize, whose RBG values are (251, 236, 93), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) maizeColor;
/*!
* Returns a UIColor object representing the color Maize, whose RBG values are (251, 236, 93), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) maizeColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Maize (Crayola), whose RBG values are (237, 209, 156), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) maizeCrayolaColor;
/*!
* Returns a UIColor object representing the color Maize (Crayola), whose RBG values are (237, 209, 156), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Majorelle Blue, whose RBG values are (96, 80, 220), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) majorelleBlueColor;
/*!
* Returns a UIColor object representing the color Majorelle Blue, whose RBG values are (96, 80, 220), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Malachite, whose RBG values are (11, 218, 81), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) malachiteColor;
/*!
* Returns a UIColor object representing the color Malachite, whose RBG values are (11, 218, 81), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Manatee (Crayola), whose RBG values are (151, 154, 170), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) manateeCrayolaColor;
/*!
* Returns a UIColor object representing the color Manatee (Crayola), whose RBG values are (151, 154, 170), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mango Tango (Crayola), whose RBG values are (255, 130, 67), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Mango Tango (Crayola), whose RBG values are (255, 130, 67), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mantis, whose RBG values are (116, 195, 101), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mantisColor;
/*!
* Returns a UIColor object representing the color Mantis, whose RBG values are (116, 195, 101), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mardi Gras, whose RBG values are (136, 0, 133), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mardiGrasColor;
/*!
* Returns a UIColor object representing the color Mardi Gras, whose RBG values are (136, 0, 133), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Marigold, whose RBG values are (234, 162, 33), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) marigoldColor;
/*!
* Returns a UIColor object representing the color Marigold, whose RBG values are (234, 162, 33), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Maroon (Crayola), whose RBG values are (200, 56, 90), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) maroonCrayolaColor;
/*!
* Returns a UIColor object representing the color Maroon (Crayola), whose RBG values are (200, 56, 90), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Maroon (HTML/CSS), whose RBG values are (128, 0, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) maroonHTMLCSSColor;
/*!
* Returns a UIColor object representing the color Maroon (HTML/CSS), whose RBG values are (128, 0, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Maroon (X11), whose RBG values are (176, 48, 96), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) maroonX11Color;
/*!
* Returns a UIColor object representing the color Maroon (X11), whose RBG values are (176, 48, 96), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mauve, whose RBG values are (224, 176, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mauveColor;
/*!
* Returns a UIColor object representing the color Mauve, whose RBG values are (224, 176, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mauveColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mauve Taupe, whose RBG values are (145, 95, 109), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mauveTaupeColor;
/*!
* Returns a UIColor object representing the color Mauve Taupe, whose RBG values are (145, 95, 109), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mauvelous (Crayola), whose RBG values are (239, 152, 170), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Mauvelous (Crayola), whose RBG values are (239, 152, 170), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color May Green, whose RBG values are (76, 145, 65), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mayGreenColor;
/*!
* Returns a UIColor object representing the color May Green, whose RBG values are (76, 145, 65), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Maya Blue, whose RBG values are (115, 194, 251), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mayaBlueColor;
/*!
* Returns a UIColor object representing the color Maya Blue, whose RBG values are (115, 194, 251), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Meat Brown, whose RBG values are (229, 183, 59), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) meatBrownColor;
/*!
* Returns a UIColor object representing the color Meat Brown, whose RBG values are (229, 183, 59), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Persian Blue, whose RBG values are (0, 103, 165), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Medium Persian Blue, whose RBG values are (0, 103, 165), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Tuscan Red, whose RBG values are (121, 68, 59), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Medium Tuscan Red, whose RBG values are (121, 68, 59), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Aquamarine, whose RBG values are (102, 221, 170), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Medium Aquamarine, whose RBG values are (102, 221, 170), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Blue, whose RBG values are (0, 0, 205), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mediumBlueColor;
/*!
* Returns a UIColor object representing the color Medium Blue, whose RBG values are (0, 0, 205), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Candy Apple Red, whose RBG values are (226, 6, 44), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Medium Candy Apple Red, whose RBG values are (226, 6, 44), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Carmine, whose RBG values are (175, 64, 53), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mediumCarmineColor;
/*!
* Returns a UIColor object representing the color Medium Carmine, whose RBG values are (175, 64, 53), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Champagne, whose RBG values are (243, 229, 171), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Medium Champagne, whose RBG values are (243, 229, 171), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Electric Blue, whose RBG values are (3, 80, 150), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Medium Electric Blue, whose RBG values are (3, 80, 150), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Jungle Green, whose RBG values are (28, 53, 45), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Medium Jungle Green, whose RBG values are (28, 53, 45), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Lavender Magenta, whose RBG values are (221, 160, 221), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Medium Lavender Magenta, whose RBG values are (221, 160, 221), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Orchid, whose RBG values are (186, 85, 211), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mediumOrchidColor;
/*!
* Returns a UIColor object representing the color Medium Orchid, whose RBG values are (186, 85, 211), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Purple, whose RBG values are (147, 112, 219), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mediumPurpleColor;
/*!
* Returns a UIColor object representing the color Medium Purple, whose RBG values are (147, 112, 219), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Red-Violet, whose RBG values are (187, 51, 133), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Medium Red-Violet, whose RBG values are (187, 51, 133), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Ruby, whose RBG values are (170, 64, 105), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mediumRubyColor;
/*!
* Returns a UIColor object representing the color Medium Ruby, whose RBG values are (170, 64, 105), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Sea Green, whose RBG values are (60, 179, 113), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mediumSeaGreenColor;
/*!
* Returns a UIColor object representing the color Medium Sea Green, whose RBG values are (60, 179, 113), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Sky Blue, whose RBG values are (128, 218, 235), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mediumSkyBlueColor;
/*!
* Returns a UIColor object representing the color Medium Sky Blue, whose RBG values are (128, 218, 235), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Slate Blue, whose RBG values are (123, 104, 238), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Medium Slate Blue, whose RBG values are (123, 104, 238), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Spring Bud, whose RBG values are (201, 220, 135), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Medium Spring Bud, whose RBG values are (201, 220, 135), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Spring Green, whose RBG values are (0, 250, 154), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Medium Spring Green, whose RBG values are (0, 250, 154), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Taupe, whose RBG values are (103, 76, 71), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mediumTaupeColor;
/*!
* Returns a UIColor object representing the color Medium Taupe, whose RBG values are (103, 76, 71), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Turquoise, whose RBG values are (72, 209, 204), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Medium Turquoise, whose RBG values are (72, 209, 204), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Vermilion, whose RBG values are (217, 96, 59), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Medium Vermilion, whose RBG values are (217, 96, 59), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Medium Violet-Red, whose RBG values are (199, 21, 133), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Medium Violet-Red, whose RBG values are (199, 21, 133), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mellow Apricot, whose RBG values are (248, 184, 120), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mellowApricotColor;
/*!
* Returns a UIColor object representing the color Mellow Apricot, whose RBG values are (248, 184, 120), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mellow Yellow, whose RBG values are (248, 222, 126), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mellowYellowColor;
/*!
* Returns a UIColor object representing the color Mellow Yellow, whose RBG values are (248, 222, 126), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Melon (Crayola), whose RBG values are (253, 188, 180), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) melonCrayolaColor;
/*!
* Returns a UIColor object representing the color Melon (Crayola), whose RBG values are (253, 188, 180), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Metallic Seaweed, whose RBG values are (10, 126, 140), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Metallic Seaweed, whose RBG values are (10, 126, 140), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Metallic Sunburst, whose RBG values are (156, 124, 56), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Metallic Sunburst, whose RBG values are (156, 124, 56), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mexican Pink, whose RBG values are (228, 0, 124), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mexicanPinkColor;
/*!
* Returns a UIColor object representing the color Mexican Pink, whose RBG values are (228, 0, 124), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Midnight Blue (Crayola), whose RBG values are (26, 72, 118), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Midnight Blue (Crayola), whose RBG values are (26, 72, 118), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Midnight Blue, whose RBG values are (25, 25, 112), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) midnightBlueColor;
/*!
* Returns a UIColor object representing the color Midnight Blue, whose RBG values are (25, 25, 112), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Midnight Green, whose RBG values are (0, 73, 83), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) midnightGreenColor;
/*!
* Returns a UIColor object representing the color Midnight Green, whose RBG values are (0, 73, 83), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mikado Yellow, whose RBG values are (255, 196, 12), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mikadoYellowColor;
/*!
* Returns a UIColor object representing the color Mikado Yellow, whose RBG values are (255, 196, 12), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mindaro, whose RBG values are (227, 249, 136), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mindaroColor;
/*!
* Returns a UIColor object representing the color Mindaro, whose RBG values are (227, 249, 136), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ming, whose RBG values are (54, 116, 125), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mingColor;
/*!
* Returns a UIColor object representing the color Ming, whose RBG values are (54, 116, 125), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mingColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mint, whose RBG values are (62, 180, 137), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mintColor;
/*!
* Returns a UIColor object representing the color Mint, whose RBG values are (62, 180, 137), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mintColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mint Cream, whose RBG values are (245, 255, 250), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mintCreamColor;
/*!
* Returns a UIColor object representing the color Mint Cream, whose RBG values are (245, 255, 250), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mint Green, whose RBG values are (152, 255, 152), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mintGreenColor;
/*!
* Returns a UIColor object representing the color Mint Green, whose RBG values are (152, 255, 152), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Misty Rose, whose RBG values are (255, 228, 225), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mistyRoseColor;
/*!
* Returns a UIColor object representing the color Misty Rose, whose RBG values are (255, 228, 225), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Moccasin, whose RBG values are (250, 235, 215), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) moccasinColor;
/*!
* Returns a UIColor object representing the color Moccasin, whose RBG values are (250, 235, 215), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mode Beige, whose RBG values are (150, 113, 23), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) modeBeigeColor;
/*!
* Returns a UIColor object representing the color Mode Beige, whose RBG values are (150, 113, 23), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Moonstone Blue, whose RBG values are (115, 169, 194), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) moonstoneBlueColor;
/*!
* Returns a UIColor object representing the color Moonstone Blue, whose RBG values are (115, 169, 194), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mordant Red 19, whose RBG values are (174, 12, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mordantRed19Color;
/*!
* Returns a UIColor object representing the color Mordant Red 19, whose RBG values are (174, 12, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Moss Green, whose RBG values are (138, 154, 91), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mossGreenColor;
/*!
* Returns a UIColor object representing the color Moss Green, whose RBG values are (138, 154, 91), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mountain Meadow, whose RBG values are (48, 186, 143), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mountainMeadowColor;
/*!
* Returns a UIColor object representing the color Mountain Meadow, whose RBG values are (48, 186, 143), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mountain Meadow (Crayola), whose RBG values are (48, 186, 143), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Mountain Meadow (Crayola), whose RBG values are (48, 186, 143), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mountbatten Pink, whose RBG values are (153, 122, 141), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Mountbatten Pink, whose RBG values are (153, 122, 141), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mughal Green, whose RBG values are (48, 96, 48), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mughalGreenColor;
/*!
* Returns a UIColor object representing the color Mughal Green, whose RBG values are (48, 96, 48), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mulberry (Crayola), whose RBG values are (197, 75, 140), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Mulberry (Crayola), whose RBG values are (197, 75, 140), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Mustard, whose RBG values are (255, 219, 88), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) mustardColor;
/*!
* Returns a UIColor object representing the color Mustard, whose RBG values are (255, 219, 88), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Myrtle Green, whose RBG values are (49, 120, 115), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) myrtleGreenColor;
/*!
* Returns a UIColor object representing the color Myrtle Green, whose RBG values are (49, 120, 115), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Nadeshiko Pink, whose RBG values are (246, 173, 198), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) nadeshikoPinkColor;
/*!
* Returns a UIColor object representing the color Nadeshiko Pink, whose RBG values are (246, 173, 198), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Napier Green, whose RBG values are (42, 128, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) napierGreenColor;
/*!
* Returns a UIColor object representing the color Napier Green, whose RBG values are (42, 128, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Naples Yellow, whose RBG values are (250, 218, 94), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) naplesYellowColor;
/*!
* Returns a UIColor object representing the color Naples Yellow, whose RBG values are (250, 218, 94), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Navajo White, whose RBG values are (255, 222, 173), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) navajoWhiteColor;
/*!
* Returns a UIColor object representing the color Navajo White, whose RBG values are (255, 222, 173), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Navy, whose RBG values are (0, 0, 128), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) navyColor;
/*!
* Returns a UIColor object representing the color Navy, whose RBG values are (0, 0, 128), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) navyColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Navy Blue, whose RBG values are (0, 0, 128), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) navyBlueColor;
/*!
* Returns a UIColor object representing the color Navy Blue, whose RBG values are (0, 0, 128), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Navy Blue (Crayola), whose RBG values are (25, 116, 210), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Navy Blue (Crayola), whose RBG values are (25, 116, 210), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Navy Purple, whose RBG values are (148, 87, 235), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) navyPurpleColor;
/*!
* Returns a UIColor object representing the color Navy Purple, whose RBG values are (148, 87, 235), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Neon Carrot (Crayola), whose RBG values are (255, 163, 67), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Neon Carrot (Crayola), whose RBG values are (255, 163, 67), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Neon Fuchsia, whose RBG values are (254, 65, 100), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) neonFuchsiaColor;
/*!
* Returns a UIColor object representing the color Neon Fuchsia, whose RBG values are (254, 65, 100), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Neon Green, whose RBG values are (57, 255, 20), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) neonGreenColor;
/*!
* Returns a UIColor object representing the color Neon Green, whose RBG values are (57, 255, 20), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color New Car, whose RBG values are (33, 79, 198), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) newCarColor;
/*!
* Returns a UIColor object representing the color New Car, whose RBG values are (33, 79, 198), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color New York Pink, whose RBG values are (215, 131, 127), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) newYorkPinkColor;
/*!
* Returns a UIColor object representing the color New York Pink, whose RBG values are (215, 131, 127), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Non-Photo Blue, whose RBG values are (164, 221, 237), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) nonPhotoBlueColor;
/*!
* Returns a UIColor object representing the color Non-Photo Blue, whose RBG values are (164, 221, 237), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color North Texas Green, whose RBG values are (5, 144, 51), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color North Texas Green, whose RBG values are (5, 144, 51), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Nyanza, whose RBG values are (233, 255, 219), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) nyanzaColor;
/*!
* Returns a UIColor object representing the color Nyanza, whose RBG values are (233, 255, 219), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color OU Crimson Red, whose RBG values are (153, 0, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) oUCrimsonRedColor;
/*!
* Returns a UIColor object representing the color OU Crimson Red, whose RBG values are (153, 0, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ocean Boat Blue, whose RBG values are (0, 119, 190), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) oceanBoatBlueColor;
/*!
* Returns a UIColor object representing the color Ocean Boat Blue, whose RBG values are (0, 119, 190), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ochre, whose RBG values are (204, 119, 34), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ochreColor;
/*!
* Returns a UIColor object representing the color Ochre, whose RBG values are (204, 119, 34), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ochreColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Office Green, whose RBG values are (0, 128, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) officeGreenColor;
/*!
* Returns a UIColor object representing the color Office Green, whose RBG values are (0, 128, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Old Burgundy, whose RBG values are (67, 48, 46), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) oldBurgundyColor;
/*!
* Returns a UIColor object representing the color Old Burgundy, whose RBG values are (67, 48, 46), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Old Gold, whose RBG values are (207, 181, 59), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) oldGoldColor;
/*!
* Returns a UIColor object representing the color Old Gold, whose RBG values are (207, 181, 59), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Old Heliotrope, whose RBG values are (86, 60, 92), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) oldHeliotropeColor;
/*!
* Returns a UIColor object representing the color Old Heliotrope, whose RBG values are (86, 60, 92), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Old Lace, whose RBG values are (253, 245, 230), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) oldLaceColor;
/*!
* Returns a UIColor object representing the color Old Lace, whose RBG values are (253, 245, 230), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Old Lavender, whose RBG values are (121, 104, 120), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) oldLavenderColor;
/*!
* Returns a UIColor object representing the color Old Lavender, whose RBG values are (121, 104, 120), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Old Mauve, whose RBG values are (103, 49, 71), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) oldMauveColor;
/*!
* Returns a UIColor object representing the color Old Mauve, whose RBG values are (103, 49, 71), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Old Moss Green, whose RBG values are (134, 126, 54), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) oldMossGreenColor;
/*!
* Returns a UIColor object representing the color Old Moss Green, whose RBG values are (134, 126, 54), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Old Rose, whose RBG values are (192, 128, 129), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) oldRoseColor;
/*!
* Returns a UIColor object representing the color Old Rose, whose RBG values are (192, 128, 129), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Old Silver, whose RBG values are (132, 132, 130), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) oldSilverColor;
/*!
* Returns a UIColor object representing the color Old Silver, whose RBG values are (132, 132, 130), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Olive, whose RBG values are (128, 128, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) oliveColor;
/*!
* Returns a UIColor object representing the color Olive, whose RBG values are (128, 128, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) oliveColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Olive Drab #3, whose RBG values are (107, 142, 35), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Olive Drab #3, whose RBG values are (107, 142, 35), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Olive Drab #7, whose RBG values are (60, 52, 31), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Olive Drab #7, whose RBG values are (60, 52, 31), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Olive Green (Crayola), whose RBG values are (186, 184, 108), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Olive Green (Crayola), whose RBG values are (186, 184, 108), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Olivine, whose RBG values are (154, 185, 115), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) olivineColor;
/*!
* Returns a UIColor object representing the color Olivine, whose RBG values are (154, 185, 115), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Onyx, whose RBG values are (53, 56, 57), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) onyxColor;
/*!
* Returns a UIColor object representing the color Onyx, whose RBG values are (53, 56, 57), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) onyxColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Opera Mauve, whose RBG values are (183, 132, 167), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) operaMauveColor;
/*!
* Returns a UIColor object representing the color Opera Mauve, whose RBG values are (183, 132, 167), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange (Color Wheel), whose RBG values are (255, 127, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Orange (Color Wheel), whose RBG values are (255, 127, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange (Crayola), whose RBG values are (255, 117, 56), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orangeCrayolaColor;
/*!
* Returns a UIColor object representing the color Orange (Crayola), whose RBG values are (255, 117, 56), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange (Pantone), whose RBG values are (255, 88, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orangePantoneColor;
/*!
* Returns a UIColor object representing the color Orange (Pantone), whose RBG values are (255, 88, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange (RYB), whose RBG values are (251, 153, 2), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orangeRYBColor;
/*!
* Returns a UIColor object representing the color Orange (RYB), whose RBG values are (251, 153, 2), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange (Web), whose RBG values are (255, 165, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orangeWebColor;
/*!
* Returns a UIColor object representing the color Orange (Web), whose RBG values are (255, 165, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange 100, whose RBG values are (255, 224, 178), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orange100Color;
/*!
* Returns a UIColor object representing the color Orange 100, whose RBG values are (255, 224, 178), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange 200, whose RBG values are (255, 204, 128), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orange200Color;
/*!
* Returns a UIColor object representing the color Orange 200, whose RBG values are (255, 204, 128), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange 300, whose RBG values are (255, 183, 77), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orange300Color;
/*!
* Returns a UIColor object representing the color Orange 300, whose RBG values are (255, 183, 77), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange 400, whose RBG values are (255, 167, 38), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orange400Color;
/*!
* Returns a UIColor object representing the color Orange 400, whose RBG values are (255, 167, 38), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange 50, whose RBG values are (255, 243, 224), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orange50Color;
/*!
* Returns a UIColor object representing the color Orange 50, whose RBG values are (255, 243, 224), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange 500, whose RBG values are (255, 152, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orange500Color;
/*!
* Returns a UIColor object representing the color Orange 500, whose RBG values are (255, 152, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange 600, whose RBG values are (251, 140, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orange600Color;
/*!
* Returns a UIColor object representing the color Orange 600, whose RBG values are (251, 140, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange 700, whose RBG values are (245, 124, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orange700Color;
/*!
* Returns a UIColor object representing the color Orange 700, whose RBG values are (245, 124, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange 800, whose RBG values are (239, 108, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orange800Color;
/*!
* Returns a UIColor object representing the color Orange 800, whose RBG values are (239, 108, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange 900, whose RBG values are (230, 81, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orange900Color;
/*!
* Returns a UIColor object representing the color Orange 900, whose RBG values are (230, 81, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange A100, whose RBG values are (255, 209, 128), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orangeA100Color;
/*!
* Returns a UIColor object representing the color Orange A100, whose RBG values are (255, 209, 128), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange A200, whose RBG values are (255, 171, 64), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orangeA200Color;
/*!
* Returns a UIColor object representing the color Orange A200, whose RBG values are (255, 171, 64), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange A400, whose RBG values are (255, 145, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orangeA400Color;
/*!
* Returns a UIColor object representing the color Orange A400, whose RBG values are (255, 145, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange A700, whose RBG values are (255, 109, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orangeA700Color;
/*!
* Returns a UIColor object representing the color Orange A700, whose RBG values are (255, 109, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange Red (Crayola), whose RBG values are (255, 43, 43), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Orange Red (Crayola), whose RBG values are (255, 43, 43), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange Yellow (Crayola), whose RBG values are (248, 213, 104), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Orange Yellow (Crayola), whose RBG values are (248, 213, 104), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange Peel, whose RBG values are (255, 159, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orangePeelColor;
/*!
* Returns a UIColor object representing the color Orange Peel, whose RBG values are (255, 159, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orange-Red, whose RBG values are (255, 69, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orangeRedColor;
/*!
* Returns a UIColor object representing the color Orange-Red, whose RBG values are (255, 69, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orchid, whose RBG values are (218, 112, 214), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orchidColor;
/*!
* Returns a UIColor object representing the color Orchid, whose RBG values are (218, 112, 214), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orchid (Crayola), whose RBG values are (230, 168, 215), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orchidCrayolaColor;
/*!
* Returns a UIColor object representing the color Orchid (Crayola), whose RBG values are (230, 168, 215), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orchid Pink, whose RBG values are (242, 189, 205), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) orchidPinkColor;
/*!
* Returns a UIColor object representing the color Orchid Pink, whose RBG values are (242, 189, 205), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Orioles Orange, whose RBG values are (251, 79, 20), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) oriolesOrangeColor;
/*!
* Returns a UIColor object representing the color Orioles Orange, whose RBG values are (251, 79, 20), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Otter Brown, whose RBG values are (101, 67, 33), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) otterBrownColor;
/*!
* Returns a UIColor object representing the color Otter Brown, whose RBG values are (101, 67, 33), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Outer Space (Crayola), whose RBG values are (65, 74, 76), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Outer Space (Crayola), whose RBG values are (65, 74, 76), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Outrageous Orange (Crayola), whose RBG values are (255, 110, 74), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Outrageous Orange (Crayola), whose RBG values are (255, 110, 74), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Oxford Blue, whose RBG values are (0, 33, 71), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) oxfordBlueColor;
/*!
* Returns a UIColor object representing the color Oxford Blue, whose RBG values are (0, 33, 71), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pacific Blue (Crayola), whose RBG values are (28, 169, 201), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Pacific Blue (Crayola), whose RBG values are (28, 169, 201), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pakistan Green, whose RBG values are (0, 102, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pakistanGreenColor;
/*!
* Returns a UIColor object representing the color Pakistan Green, whose RBG values are (0, 102, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Palatinate Blue, whose RBG values are (39, 59, 226), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) palatinateBlueColor;
/*!
* Returns a UIColor object representing the color Palatinate Blue, whose RBG values are (39, 59, 226), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Palatinate Purple, whose RBG values are (104, 40, 96), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Palatinate Purple, whose RBG values are (104, 40, 96), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Aqua, whose RBG values are (188, 212, 230), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) paleAquaColor;
/*!
* Returns a UIColor object representing the color Pale Aqua, whose RBG values are (188, 212, 230), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Blue, whose RBG values are (175, 238, 238), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) paleBlueColor;
/*!
* Returns a UIColor object representing the color Pale Blue, whose RBG values are (175, 238, 238), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Brown, whose RBG values are (152, 118, 84), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) paleBrownColor;
/*!
* Returns a UIColor object representing the color Pale Brown, whose RBG values are (152, 118, 84), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Carmine, whose RBG values are (175, 64, 53), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) paleCarmineColor;
/*!
* Returns a UIColor object representing the color Pale Carmine, whose RBG values are (175, 64, 53), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Cerulean, whose RBG values are (155, 196, 226), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) paleCeruleanColor;
/*!
* Returns a UIColor object representing the color Pale Cerulean, whose RBG values are (155, 196, 226), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Chestnut, whose RBG values are (221, 173, 175), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) paleChestnutColor;
/*!
* Returns a UIColor object representing the color Pale Chestnut, whose RBG values are (221, 173, 175), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Copper, whose RBG values are (218, 138, 103), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) paleCopperColor;
/*!
* Returns a UIColor object representing the color Pale Copper, whose RBG values are (218, 138, 103), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Cornflower Blue, whose RBG values are (171, 205, 239), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Pale Cornflower Blue, whose RBG values are (171, 205, 239), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Cyan, whose RBG values are (135, 211, 248), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) paleCyanColor;
/*!
* Returns a UIColor object representing the color Pale Cyan, whose RBG values are (135, 211, 248), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Gold, whose RBG values are (230, 190, 138), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) paleGoldColor;
/*!
* Returns a UIColor object representing the color Pale Gold, whose RBG values are (230, 190, 138), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Goldenrod, whose RBG values are (238, 232, 170), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) paleGoldenrodColor;
/*!
* Returns a UIColor object representing the color Pale Goldenrod, whose RBG values are (238, 232, 170), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Green, whose RBG values are (152, 251, 152), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) paleGreenColor;
/*!
* Returns a UIColor object representing the color Pale Green, whose RBG values are (152, 251, 152), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Lavender, whose RBG values are (220, 208, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) paleLavenderColor;
/*!
* Returns a UIColor object representing the color Pale Lavender, whose RBG values are (220, 208, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Magenta, whose RBG values are (249, 132, 229), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) paleMagentaColor;
/*!
* Returns a UIColor object representing the color Pale Magenta, whose RBG values are (249, 132, 229), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Magenta-Pink, whose RBG values are (255, 153, 204), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Pale Magenta-Pink, whose RBG values are (255, 153, 204), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Pink, whose RBG values are (250, 218, 221), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) palePinkColor;
/*!
* Returns a UIColor object representing the color Pale Pink, whose RBG values are (250, 218, 221), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Plum, whose RBG values are (221, 160, 221), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) palePlumColor;
/*!
* Returns a UIColor object representing the color Pale Plum, whose RBG values are (221, 160, 221), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Red-Violet, whose RBG values are (219, 112, 147), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) paleRedVioletColor;
/*!
* Returns a UIColor object representing the color Pale Red-Violet, whose RBG values are (219, 112, 147), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Robin Egg Blue, whose RBG values are (150, 222, 209), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Pale Robin Egg Blue, whose RBG values are (150, 222, 209), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Silver, whose RBG values are (201, 192, 187), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) paleSilverColor;
/*!
* Returns a UIColor object representing the color Pale Silver, whose RBG values are (201, 192, 187), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Spring Bud, whose RBG values are (236, 235, 189), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) paleSpringBudColor;
/*!
* Returns a UIColor object representing the color Pale Spring Bud, whose RBG values are (236, 235, 189), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Taupe, whose RBG values are (188, 152, 126), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) paleTaupeColor;
/*!
* Returns a UIColor object representing the color Pale Taupe, whose RBG values are (188, 152, 126), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Turquoise, whose RBG values are (175, 238, 238), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) paleTurquoiseColor;
/*!
* Returns a UIColor object representing the color Pale Turquoise, whose RBG values are (175, 238, 238), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Violet, whose RBG values are (204, 153, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) paleVioletColor;
/*!
* Returns a UIColor object representing the color Pale Violet, whose RBG values are (204, 153, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pale Violet-Red, whose RBG values are (219, 112, 147), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) paleVioletRedColor;
/*!
* Returns a UIColor object representing the color Pale Violet-Red, whose RBG values are (219, 112, 147), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pansy Purple, whose RBG values are (120, 24, 74), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pansyPurpleColor;
/*!
* Returns a UIColor object representing the color Pansy Purple, whose RBG values are (120, 24, 74), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Paolo Veronese Green, whose RBG values are (0, 155, 125), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Paolo Veronese Green, whose RBG values are (0, 155, 125), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Papaya Whip, whose RBG values are (255, 239, 213), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) papayaWhipColor;
/*!
* Returns a UIColor object representing the color Papaya Whip, whose RBG values are (255, 239, 213), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Paradise Pink, whose RBG values are (230, 62, 98), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) paradisePinkColor;
/*!
* Returns a UIColor object representing the color Paradise Pink, whose RBG values are (230, 62, 98), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Paris Green, whose RBG values are (80, 200, 120), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) parisGreenColor;
/*!
* Returns a UIColor object representing the color Paris Green, whose RBG values are (80, 200, 120), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pastel Blue, whose RBG values are (174, 198, 207), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pastelBlueColor;
/*!
* Returns a UIColor object representing the color Pastel Blue, whose RBG values are (174, 198, 207), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pastel Brown, whose RBG values are (130, 105, 83), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pastelBrownColor;
/*!
* Returns a UIColor object representing the color Pastel Brown, whose RBG values are (130, 105, 83), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pastel Gray, whose RBG values are (207, 207, 196), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pastelGrayColor;
/*!
* Returns a UIColor object representing the color Pastel Gray, whose RBG values are (207, 207, 196), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pastel Green, whose RBG values are (119, 221, 119), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pastelGreenColor;
/*!
* Returns a UIColor object representing the color Pastel Green, whose RBG values are (119, 221, 119), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pastel Magenta, whose RBG values are (244, 154, 194), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pastelMagentaColor;
/*!
* Returns a UIColor object representing the color Pastel Magenta, whose RBG values are (244, 154, 194), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pastel Orange, whose RBG values are (255, 179, 71), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pastelOrangeColor;
/*!
* Returns a UIColor object representing the color Pastel Orange, whose RBG values are (255, 179, 71), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pastel Pink, whose RBG values are (222, 165, 164), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pastelPinkColor;
/*!
* Returns a UIColor object representing the color Pastel Pink, whose RBG values are (222, 165, 164), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pastel Purple, whose RBG values are (179, 158, 181), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pastelPurpleColor;
/*!
* Returns a UIColor object representing the color Pastel Purple, whose RBG values are (179, 158, 181), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pastel Red, whose RBG values are (255, 105, 97), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pastelRedColor;
/*!
* Returns a UIColor object representing the color Pastel Red, whose RBG values are (255, 105, 97), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pastel Violet, whose RBG values are (203, 153, 201), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pastelVioletColor;
/*!
* Returns a UIColor object representing the color Pastel Violet, whose RBG values are (203, 153, 201), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pastel Yellow, whose RBG values are (253, 253, 150), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pastelYellowColor;
/*!
* Returns a UIColor object representing the color Pastel Yellow, whose RBG values are (253, 253, 150), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Patriarch, whose RBG values are (128, 0, 128), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) patriarchColor;
/*!
* Returns a UIColor object representing the color Patriarch, whose RBG values are (128, 0, 128), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Payne's Grey, whose RBG values are (83, 104, 120), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) paynesGreyColor;
/*!
* Returns a UIColor object representing the color Payne's Grey, whose RBG values are (83, 104, 120), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Peach, whose RBG values are (255, 229, 180), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) peachColor;
/*!
* Returns a UIColor object representing the color Peach, whose RBG values are (255, 229, 180), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) peachColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Peach (Crayola), whose RBG values are (255, 207, 171), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) peachCrayolaColor;
/*!
* Returns a UIColor object representing the color Peach (Crayola), whose RBG values are (255, 207, 171), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Peach Puff, whose RBG values are (255, 218, 185), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) peachPuffColor;
/*!
* Returns a UIColor object representing the color Peach Puff, whose RBG values are (255, 218, 185), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Peach-Orange, whose RBG values are (255, 204, 153), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) peachOrangeColor;
/*!
* Returns a UIColor object representing the color Peach-Orange, whose RBG values are (255, 204, 153), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Peach-Yellow, whose RBG values are (250, 223, 173), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) peachYellowColor;
/*!
* Returns a UIColor object representing the color Peach-Yellow, whose RBG values are (250, 223, 173), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pear, whose RBG values are (209, 226, 49), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pearColor;
/*!
* Returns a UIColor object representing the color Pear, whose RBG values are (209, 226, 49), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pearColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pearl, whose RBG values are (234, 224, 200), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pearlColor;
/*!
* Returns a UIColor object representing the color Pearl, whose RBG values are (234, 224, 200), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pearlColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pearl Aqua, whose RBG values are (136, 216, 192), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pearlAquaColor;
/*!
* Returns a UIColor object representing the color Pearl Aqua, whose RBG values are (136, 216, 192), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pearly Purple, whose RBG values are (183, 104, 162), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pearlyPurpleColor;
/*!
* Returns a UIColor object representing the color Pearly Purple, whose RBG values are (183, 104, 162), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Peridot, whose RBG values are (230, 226, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) peridotColor;
/*!
* Returns a UIColor object representing the color Peridot, whose RBG values are (230, 226, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Periwinkle, whose RBG values are (204, 204, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) periwinkleColor;
/*!
* Returns a UIColor object representing the color Periwinkle, whose RBG values are (204, 204, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Periwinkle (Crayola), whose RBG values are (197, 208, 230), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Periwinkle (Crayola), whose RBG values are (197, 208, 230), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Persian Blue, whose RBG values are (28, 57, 187), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) persianBlueColor;
/*!
* Returns a UIColor object representing the color Persian Blue, whose RBG values are (28, 57, 187), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Persian Green, whose RBG values are (0, 166, 147), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) persianGreenColor;
/*!
* Returns a UIColor object representing the color Persian Green, whose RBG values are (0, 166, 147), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Persian Indigo, whose RBG values are (50, 18, 122), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) persianIndigoColor;
/*!
* Returns a UIColor object representing the color Persian Indigo, whose RBG values are (50, 18, 122), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Persian Orange, whose RBG values are (217, 144, 88), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) persianOrangeColor;
/*!
* Returns a UIColor object representing the color Persian Orange, whose RBG values are (217, 144, 88), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Persian Pink, whose RBG values are (247, 127, 190), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) persianPinkColor;
/*!
* Returns a UIColor object representing the color Persian Pink, whose RBG values are (247, 127, 190), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Persian Plum, whose RBG values are (112, 28, 28), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) persianPlumColor;
/*!
* Returns a UIColor object representing the color Persian Plum, whose RBG values are (112, 28, 28), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Persian Red, whose RBG values are (204, 51, 51), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) persianRedColor;
/*!
* Returns a UIColor object representing the color Persian Red, whose RBG values are (204, 51, 51), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Persian Rose, whose RBG values are (254, 40, 162), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) persianRoseColor;
/*!
* Returns a UIColor object representing the color Persian Rose, whose RBG values are (254, 40, 162), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Persimmon, whose RBG values are (236, 88, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) persimmonColor;
/*!
* Returns a UIColor object representing the color Persimmon, whose RBG values are (236, 88, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Peru, whose RBG values are (205, 133, 63), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) peruColor;
/*!
* Returns a UIColor object representing the color Peru, whose RBG values are (205, 133, 63), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) peruColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Phlox, whose RBG values are (223, 0, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) phloxColor;
/*!
* Returns a UIColor object representing the color Phlox, whose RBG values are (223, 0, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) phloxColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Phthalo Blue, whose RBG values are (0, 15, 137), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) phthaloBlueColor;
/*!
* Returns a UIColor object representing the color Phthalo Blue, whose RBG values are (0, 15, 137), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Phthalo Green, whose RBG values are (18, 53, 36), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) phthaloGreenColor;
/*!
* Returns a UIColor object representing the color Phthalo Green, whose RBG values are (18, 53, 36), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Picton Blue, whose RBG values are (69, 177, 232), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pictonBlueColor;
/*!
* Returns a UIColor object representing the color Picton Blue, whose RBG values are (69, 177, 232), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pictorial Carmine, whose RBG values are (195, 11, 78), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Pictorial Carmine, whose RBG values are (195, 11, 78), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Piggy Pink (Crayola), whose RBG values are (253, 221, 230), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Piggy Pink (Crayola), whose RBG values are (253, 221, 230), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pine Green (Crayola), whose RBG values are (21, 128, 120), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Pine Green (Crayola), whose RBG values are (21, 128, 120), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pine Green, whose RBG values are (1, 121, 111), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pineGreenColor;
/*!
* Returns a UIColor object representing the color Pine Green, whose RBG values are (1, 121, 111), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pineapple, whose RBG values are (86, 60, 13), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pineappleColor;
/*!
* Returns a UIColor object representing the color Pineapple, whose RBG values are (86, 60, 13), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink, whose RBG values are (255, 192, 203), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pinkColor;
/*!
* Returns a UIColor object representing the color Pink, whose RBG values are (255, 192, 203), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pinkColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink (Pantone), whose RBG values are (215, 72, 148), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pinkPantoneColor;
/*!
* Returns a UIColor object representing the color Pink (Pantone), whose RBG values are (215, 72, 148), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink 100, whose RBG values are (248, 187, 208), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pink100Color;
/*!
* Returns a UIColor object representing the color Pink 100, whose RBG values are (248, 187, 208), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink 200, whose RBG values are (244, 143, 177), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pink200Color;
/*!
* Returns a UIColor object representing the color Pink 200, whose RBG values are (244, 143, 177), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink 300, whose RBG values are (240, 98, 146), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pink300Color;
/*!
* Returns a UIColor object representing the color Pink 300, whose RBG values are (240, 98, 146), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink 400, whose RBG values are (236, 64, 122), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pink400Color;
/*!
* Returns a UIColor object representing the color Pink 400, whose RBG values are (236, 64, 122), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink 50, whose RBG values are (252, 228, 236), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pink50Color;
/*!
* Returns a UIColor object representing the color Pink 50, whose RBG values are (252, 228, 236), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink 500, whose RBG values are (233, 30, 99), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pink500Color;
/*!
* Returns a UIColor object representing the color Pink 500, whose RBG values are (233, 30, 99), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink 600, whose RBG values are (216, 27, 96), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pink600Color;
/*!
* Returns a UIColor object representing the color Pink 600, whose RBG values are (216, 27, 96), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink 700, whose RBG values are (194, 24, 91), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pink700Color;
/*!
* Returns a UIColor object representing the color Pink 700, whose RBG values are (194, 24, 91), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink 800, whose RBG values are (173, 20, 87), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pink800Color;
/*!
* Returns a UIColor object representing the color Pink 800, whose RBG values are (173, 20, 87), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink 900, whose RBG values are (136, 14, 79), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pink900Color;
/*!
* Returns a UIColor object representing the color Pink 900, whose RBG values are (136, 14, 79), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink A100, whose RBG values are (255, 128, 171), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pinkA100Color;
/*!
* Returns a UIColor object representing the color Pink A100, whose RBG values are (255, 128, 171), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink A200, whose RBG values are (255, 64, 129), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pinkA200Color;
/*!
* Returns a UIColor object representing the color Pink A200, whose RBG values are (255, 64, 129), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink A400, whose RBG values are (245, 0, 87), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pinkA400Color;
/*!
* Returns a UIColor object representing the color Pink A400, whose RBG values are (245, 0, 87), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink A700, whose RBG values are (197, 17, 98), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pinkA700Color;
/*!
* Returns a UIColor object representing the color Pink A700, whose RBG values are (197, 17, 98), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink Flamingo (Crayola), whose RBG values are (252, 116, 253), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Pink Flamingo (Crayola), whose RBG values are (252, 116, 253), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink Sherbert (Crayola), whose RBG values are (247, 143, 167), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Pink Sherbert (Crayola), whose RBG values are (247, 143, 167), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink Lace, whose RBG values are (255, 221, 244), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pinkLaceColor;
/*!
* Returns a UIColor object representing the color Pink Lace, whose RBG values are (255, 221, 244), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink Lavender, whose RBG values are (216, 178, 209), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pinkLavenderColor;
/*!
* Returns a UIColor object representing the color Pink Lavender, whose RBG values are (216, 178, 209), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink Pearl, whose RBG values are (231, 172, 207), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pinkPearlColor;
/*!
* Returns a UIColor object representing the color Pink Pearl, whose RBG values are (231, 172, 207), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink Raspberry, whose RBG values are (152, 0, 54), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pinkRaspberryColor;
/*!
* Returns a UIColor object representing the color Pink Raspberry, whose RBG values are (152, 0, 54), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pink-Orange, whose RBG values are (255, 153, 102), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pinkOrangeColor;
/*!
* Returns a UIColor object representing the color Pink-Orange, whose RBG values are (255, 153, 102), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pistachio, whose RBG values are (147, 197, 114), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pistachioColor;
/*!
* Returns a UIColor object representing the color Pistachio, whose RBG values are (147, 197, 114), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Platinum, whose RBG values are (229, 228, 226), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) platinumColor;
/*!
* Returns a UIColor object representing the color Platinum, whose RBG values are (229, 228, 226), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Plum, whose RBG values are (142, 69, 133), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) plumColor;
/*!
* Returns a UIColor object representing the color Plum, whose RBG values are (142, 69, 133), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) plumColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Plum (Crayola), whose RBG values are (142, 69, 133), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) plumCrayolaColor;
/*!
* Returns a UIColor object representing the color Plum (Crayola), whose RBG values are (142, 69, 133), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Plum (Web), whose RBG values are (221, 160, 221), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) plumWebColor;
/*!
* Returns a UIColor object representing the color Plum (Web), whose RBG values are (221, 160, 221), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pomp And Power, whose RBG values are (134, 96, 142), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pompAndPowerColor;
/*!
* Returns a UIColor object representing the color Pomp And Power, whose RBG values are (134, 96, 142), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Popstar, whose RBG values are (190, 79, 98), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) popstarColor;
/*!
* Returns a UIColor object representing the color Popstar, whose RBG values are (190, 79, 98), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Portland Orange, whose RBG values are (255, 90, 54), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) portlandOrangeColor;
/*!
* Returns a UIColor object representing the color Portland Orange, whose RBG values are (255, 90, 54), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Powder Blue, whose RBG values are (176, 224, 230), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) powderBlueColor;
/*!
* Returns a UIColor object representing the color Powder Blue, whose RBG values are (176, 224, 230), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Princeton Orange, whose RBG values are (245, 128, 37), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Princeton Orange, whose RBG values are (245, 128, 37), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Prune, whose RBG values are (112, 28, 28), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pruneColor;
/*!
* Returns a UIColor object representing the color Prune, whose RBG values are (112, 28, 28), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pruneColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Prussian Blue, whose RBG values are (0, 49, 83), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) prussianBlueColor;
/*!
* Returns a UIColor object representing the color Prussian Blue, whose RBG values are (0, 49, 83), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Psychedelic Purple, whose RBG values are (223, 0, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Psychedelic Purple, whose RBG values are (223, 0, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Puce, whose RBG values are (204, 136, 153), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) puceColor;
/*!
* Returns a UIColor object representing the color Puce, whose RBG values are (204, 136, 153), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) puceColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Puce Red, whose RBG values are (114, 47, 55), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) puceRedColor;
/*!
* Returns a UIColor object representing the color Puce Red, whose RBG values are (114, 47, 55), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pullman Brown (UPS Brown), whose RBG values are (100, 65, 23), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Pullman Brown (UPS Brown), whose RBG values are (100, 65, 23), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pullman Green, whose RBG values are (59, 51, 28), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pullmanGreenColor;
/*!
* Returns a UIColor object representing the color Pullman Green, whose RBG values are (59, 51, 28), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Pumpkin, whose RBG values are (255, 117, 24), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) pumpkinColor;
/*!
* Returns a UIColor object representing the color Pumpkin, whose RBG values are (255, 117, 24), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple (HTML), whose RBG values are (128, 0, 128), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) purpleHTMLColor;
/*!
* Returns a UIColor object representing the color Purple (HTML), whose RBG values are (128, 0, 128), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple (Munsell), whose RBG values are (159, 0, 197), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) purpleMunsellColor;
/*!
* Returns a UIColor object representing the color Purple (Munsell), whose RBG values are (159, 0, 197), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple (X11), whose RBG values are (160, 32, 240), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) purpleX11Color;
/*!
* Returns a UIColor object representing the color Purple (X11), whose RBG values are (160, 32, 240), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple 100, whose RBG values are (225, 190, 231), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) purple100Color;
/*!
* Returns a UIColor object representing the color Purple 100, whose RBG values are (225, 190, 231), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple 200, whose RBG values are (206, 147, 216), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) purple200Color;
/*!
* Returns a UIColor object representing the color Purple 200, whose RBG values are (206, 147, 216), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple 300, whose RBG values are (186, 104, 200), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) purple300Color;
/*!
* Returns a UIColor object representing the color Purple 300, whose RBG values are (186, 104, 200), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple 400, whose RBG values are (171, 71, 188), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) purple400Color;
/*!
* Returns a UIColor object representing the color Purple 400, whose RBG values are (171, 71, 188), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple 50, whose RBG values are (243, 229, 245), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) purple50Color;
/*!
* Returns a UIColor object representing the color Purple 50, whose RBG values are (243, 229, 245), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple 500, whose RBG values are (156, 39, 176), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) purple500Color;
/*!
* Returns a UIColor object representing the color Purple 500, whose RBG values are (156, 39, 176), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple 600, whose RBG values are (142, 36, 170), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) purple600Color;
/*!
* Returns a UIColor object representing the color Purple 600, whose RBG values are (142, 36, 170), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple 700, whose RBG values are (123, 31, 162), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) purple700Color;
/*!
* Returns a UIColor object representing the color Purple 700, whose RBG values are (123, 31, 162), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple 800, whose RBG values are (106, 27, 154), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) purple800Color;
/*!
* Returns a UIColor object representing the color Purple 800, whose RBG values are (106, 27, 154), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple 900, whose RBG values are (74, 20, 140), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) purple900Color;
/*!
* Returns a UIColor object representing the color Purple 900, whose RBG values are (74, 20, 140), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple A100, whose RBG values are (234, 128, 252), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) purpleA100Color;
/*!
* Returns a UIColor object representing the color Purple A100, whose RBG values are (234, 128, 252), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple A200, whose RBG values are (224, 64, 251), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) purpleA200Color;
/*!
* Returns a UIColor object representing the color Purple A200, whose RBG values are (224, 64, 251), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple A400, whose RBG values are (213, 0, 249), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) purpleA400Color;
/*!
* Returns a UIColor object representing the color Purple A400, whose RBG values are (213, 0, 249), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple A700, whose RBG values are (170, 0, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) purpleA700Color;
/*!
* Returns a UIColor object representing the color Purple A700, whose RBG values are (170, 0, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple Heart, whose RBG values are (105, 53, 156), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) purpleHeartColor;
/*!
* Returns a UIColor object representing the color Purple Heart, whose RBG values are (105, 53, 156), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple Heart (Crayola), whose RBG values are (116, 66, 200), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Purple Heart (Crayola), whose RBG values are (116, 66, 200), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple Mountains' Majesty (Crayola), whose RBG values are (157, 129, 186), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Purple Mountains' Majesty (Crayola), whose RBG values are (157, 129, 186), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple Pizzazz (Crayola), whose RBG values are (254, 78, 218), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Purple Pizzazz (Crayola), whose RBG values are (254, 78, 218), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple Mountain Majesty, whose RBG values are (150, 120, 182), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Purple Mountain Majesty, whose RBG values are (150, 120, 182), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple Navy, whose RBG values are (78, 81, 128), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) purpleNavyColor;
/*!
* Returns a UIColor object representing the color Purple Navy, whose RBG values are (78, 81, 128), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purple Taupe, whose RBG values are (80, 64, 77), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) purpleTaupeColor;
/*!
* Returns a UIColor object representing the color Purple Taupe, whose RBG values are (80, 64, 77), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Purpureus, whose RBG values are (154, 78, 174), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) purpureusColor;
/*!
* Returns a UIColor object representing the color Purpureus, whose RBG values are (154, 78, 174), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Quartz, whose RBG values are (81, 72, 79), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) quartzColor;
/*!
* Returns a UIColor object representing the color Quartz, whose RBG values are (81, 72, 79), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Queen Blue, whose RBG values are (67, 107, 149), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) queenBlueColor;
/*!
* Returns a UIColor object representing the color Queen Blue, whose RBG values are (67, 107, 149), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Queen Pink, whose RBG values are (232, 204, 215), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) queenPinkColor;
/*!
* Returns a UIColor object representing the color Queen Pink, whose RBG values are (232, 204, 215), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Quinacridone Magenta, whose RBG values are (142, 58, 89), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Quinacridone Magenta, whose RBG values are (142, 58, 89), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rackley, whose RBG values are (93, 138, 168), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) rackleyColor;
/*!
* Returns a UIColor object representing the color Rackley, whose RBG values are (93, 138, 168), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Radical Red, whose RBG values are (255, 53, 94), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) radicalRedColor;
/*!
* Returns a UIColor object representing the color Radical Red, whose RBG values are (255, 53, 94), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Radical Red (Crayola), whose RBG values are (255, 73, 108), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Radical Red (Crayola), whose RBG values are (255, 73, 108), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rajah, whose RBG values are (251, 171, 96), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) rajahColor;
/*!
* Returns a UIColor object representing the color Rajah, whose RBG values are (251, 171, 96), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) rajahColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Raspberry, whose RBG values are (227, 11, 92), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) raspberryColor;
/*!
* Returns a UIColor object representing the color Raspberry, whose RBG values are (227, 11, 92), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Raspberry Glace, whose RBG values are (145, 95, 109), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) raspberryGlaceColor;
/*!
* Returns a UIColor object representing the color Raspberry Glace, whose RBG values are (145, 95, 109), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Raspberry Pink, whose RBG values are (226, 80, 152), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) raspberryPinkColor;
/*!
* Returns a UIColor object representing the color Raspberry Pink, whose RBG values are (226, 80, 152), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Raspberry Rose, whose RBG values are (179, 68, 108), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) raspberryRoseColor;
/*!
* Returns a UIColor object representing the color Raspberry Rose, whose RBG values are (179, 68, 108), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Raw Sienna (Crayola), whose RBG values are (214, 138, 89), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Raw Sienna (Crayola), whose RBG values are (214, 138, 89), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Raw Umber (Crayola), whose RBG values are (113, 75, 35), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Raw Umber (Crayola), whose RBG values are (113, 75, 35), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Raw Umber, whose RBG values are (130, 102, 68), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) rawUmberColor;
/*!
* Returns a UIColor object representing the color Raw Umber, whose RBG values are (130, 102, 68), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Razzle Dazzle Rose (Crayola), whose RBG values are (255, 72, 208), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Razzle Dazzle Rose (Crayola), whose RBG values are (255, 72, 208), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Razzle Dazzle Rose, whose RBG values are (255, 51, 204), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Razzle Dazzle Rose, whose RBG values are (255, 51, 204), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Razzmatazz (Crayola), whose RBG values are (227, 37, 107), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Razzmatazz (Crayola), whose RBG values are (227, 37, 107), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Razzmic Berry, whose RBG values are (141, 78, 133), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) razzmicBerryColor;
/*!
* Returns a UIColor object representing the color Razzmic Berry, whose RBG values are (141, 78, 133), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rebecca Purple, whose RBG values are (102, 52, 153), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) rebeccaPurpleColor;
/*!
* Returns a UIColor object representing the color Rebecca Purple, whose RBG values are (102, 52, 153), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red (Crayola), whose RBG values are (238, 32, 77), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) redCrayolaColor;
/*!
* Returns a UIColor object representing the color Red (Crayola), whose RBG values are (238, 32, 77), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red (Munsell), whose RBG values are (242, 0, 60), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) redMunsellColor;
/*!
* Returns a UIColor object representing the color Red (Munsell), whose RBG values are (242, 0, 60), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red (NCS), whose RBG values are (196, 2, 51), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) redNCSColor;
/*!
* Returns a UIColor object representing the color Red (NCS), whose RBG values are (196, 2, 51), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red (Pantone), whose RBG values are (237, 41, 57), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) redPantoneColor;
/*!
* Returns a UIColor object representing the color Red (Pantone), whose RBG values are (237, 41, 57), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red (Pigment), whose RBG values are (237, 28, 36), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) redPigmentColor;
/*!
* Returns a UIColor object representing the color Red (Pigment), whose RBG values are (237, 28, 36), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red (RYB), whose RBG values are (254, 39, 18), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) redRYBColor;
/*!
* Returns a UIColor object representing the color Red (RYB), whose RBG values are (254, 39, 18), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red 100, whose RBG values are (255, 205, 210), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) red100Color;
/*!
* Returns a UIColor object representing the color Red 100, whose RBG values are (255, 205, 210), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red 200, whose RBG values are (239, 154, 154), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) red200Color;
/*!
* Returns a UIColor object representing the color Red 200, whose RBG values are (239, 154, 154), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red 300, whose RBG values are (229, 115, 115), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) red300Color;
/*!
* Returns a UIColor object representing the color Red 300, whose RBG values are (229, 115, 115), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red 400, whose RBG values are (239, 83, 80), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) red400Color;
/*!
* Returns a UIColor object representing the color Red 400, whose RBG values are (239, 83, 80), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red 50, whose RBG values are (255, 235, 238), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) red50Color;
/*!
* Returns a UIColor object representing the color Red 50, whose RBG values are (255, 235, 238), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) red50ColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red 500, whose RBG values are (244, 67, 54), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) red500Color;
/*!
* Returns a UIColor object representing the color Red 500, whose RBG values are (244, 67, 54), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red 600, whose RBG values are (229, 57, 53), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) red600Color;
/*!
* Returns a UIColor object representing the color Red 600, whose RBG values are (229, 57, 53), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red 700, whose RBG values are (211, 47, 47), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) red700Color;
/*!
* Returns a UIColor object representing the color Red 700, whose RBG values are (211, 47, 47), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red 800, whose RBG values are (198, 40, 40), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) red800Color;
/*!
* Returns a UIColor object representing the color Red 800, whose RBG values are (198, 40, 40), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red 900, whose RBG values are (183, 28, 28), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) red900Color;
/*!
* Returns a UIColor object representing the color Red 900, whose RBG values are (183, 28, 28), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red A100, whose RBG values are (255, 138, 128), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) redA100Color;
/*!
* Returns a UIColor object representing the color Red A100, whose RBG values are (255, 138, 128), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red A200, whose RBG values are (255, 82, 82), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) redA200Color;
/*!
* Returns a UIColor object representing the color Red A200, whose RBG values are (255, 82, 82), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red A400, whose RBG values are (255, 23, 68), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) redA400Color;
/*!
* Returns a UIColor object representing the color Red A400, whose RBG values are (255, 23, 68), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red A700, whose RBG values are (213, 0, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) redA700Color;
/*!
* Returns a UIColor object representing the color Red A700, whose RBG values are (213, 0, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red Orange (Crayola), whose RBG values are (255, 83, 73), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Red Orange (Crayola), whose RBG values are (255, 83, 73), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red Violet (Crayola), whose RBG values are (192, 68, 143), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Red Violet (Crayola), whose RBG values are (192, 68, 143), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red Devil, whose RBG values are (134, 1, 17), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) redDevilColor;
/*!
* Returns a UIColor object representing the color Red Devil, whose RBG values are (134, 1, 17), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red-Brown, whose RBG values are (165, 42, 42), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) redBrownColor;
/*!
* Returns a UIColor object representing the color Red-Brown, whose RBG values are (165, 42, 42), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red-Purple, whose RBG values are (228, 0, 120), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) redPurpleColor;
/*!
* Returns a UIColor object representing the color Red-Purple, whose RBG values are (228, 0, 120), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Red-Violet, whose RBG values are (199, 21, 133), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) redVioletColor;
/*!
* Returns a UIColor object representing the color Red-Violet, whose RBG values are (199, 21, 133), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Redwood, whose RBG values are (164, 90, 82), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) redwoodColor;
/*!
* Returns a UIColor object representing the color Redwood, whose RBG values are (164, 90, 82), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Regalia, whose RBG values are (82, 45, 128), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) regaliaColor;
/*!
* Returns a UIColor object representing the color Regalia, whose RBG values are (82, 45, 128), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Registration Black, whose RBG values are (0, 0, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Registration Black, whose RBG values are (0, 0, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Resolution Blue, whose RBG values are (0, 35, 135), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) resolutionBlueColor;
/*!
* Returns a UIColor object representing the color Resolution Blue, whose RBG values are (0, 35, 135), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rhythm, whose RBG values are (119, 118, 150), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) rhythmColor;
/*!
* Returns a UIColor object representing the color Rhythm, whose RBG values are (119, 118, 150), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rich Black, whose RBG values are (0, 64, 64), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) richBlackColor;
/*!
* Returns a UIColor object representing the color Rich Black, whose RBG values are (0, 64, 64), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rich Black (FOGRA29), whose RBG values are (1, 11, 19), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Rich Black (FOGRA29), whose RBG values are (1, 11, 19), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rich Black (FOGRA39), whose RBG values are (1, 2, 3), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Rich Black (FOGRA39), whose RBG values are (1, 2, 3), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rich Brilliant Lavender, whose RBG values are (241, 167, 254), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Rich Brilliant Lavender, whose RBG values are (241, 167, 254), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rich Carmine, whose RBG values are (215, 0, 64), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) richCarmineColor;
/*!
* Returns a UIColor object representing the color Rich Carmine, whose RBG values are (215, 0, 64), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rich Electric Blue, whose RBG values are (8, 146, 208), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Rich Electric Blue, whose RBG values are (8, 146, 208), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rich Lavender, whose RBG values are (167, 107, 207), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) richLavenderColor;
/*!
* Returns a UIColor object representing the color Rich Lavender, whose RBG values are (167, 107, 207), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rich Lilac, whose RBG values are (182, 102, 210), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) richLilacColor;
/*!
* Returns a UIColor object representing the color Rich Lilac, whose RBG values are (182, 102, 210), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rich Maroon, whose RBG values are (176, 48, 96), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) richMaroonColor;
/*!
* Returns a UIColor object representing the color Rich Maroon, whose RBG values are (176, 48, 96), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rifle Green, whose RBG values are (68, 76, 56), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) rifleGreenColor;
/*!
* Returns a UIColor object representing the color Rifle Green, whose RBG values are (68, 76, 56), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Roast Coffee, whose RBG values are (112, 66, 65), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) roastCoffeeColor;
/*!
* Returns a UIColor object representing the color Roast Coffee, whose RBG values are (112, 66, 65), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Robin Egg Blue, whose RBG values are (0, 204, 204), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) robinEggBlueColor;
/*!
* Returns a UIColor object representing the color Robin Egg Blue, whose RBG values are (0, 204, 204), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Robin's Egg Blue (Crayola), whose RBG values are (31, 206, 203), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Robin's Egg Blue (Crayola), whose RBG values are (31, 206, 203), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rocket Metallic, whose RBG values are (138, 127, 128), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) rocketMetallicColor;
/*!
* Returns a UIColor object representing the color Rocket Metallic, whose RBG values are (138, 127, 128), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Roman Silver, whose RBG values are (131, 137, 150), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) romanSilverColor;
/*!
* Returns a UIColor object representing the color Roman Silver, whose RBG values are (131, 137, 150), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rose, whose RBG values are (255, 0, 127), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) roseColor;
/*!
* Returns a UIColor object representing the color Rose, whose RBG values are (255, 0, 127), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) roseColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rose Bonbon, whose RBG values are (249, 66, 158), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) roseBonbonColor;
/*!
* Returns a UIColor object representing the color Rose Bonbon, whose RBG values are (249, 66, 158), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rose Ebony, whose RBG values are (103, 72, 70), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) roseEbonyColor;
/*!
* Returns a UIColor object representing the color Rose Ebony, whose RBG values are (103, 72, 70), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rose Gold, whose RBG values are (183, 110, 121), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) roseGoldColor;
/*!
* Returns a UIColor object representing the color Rose Gold, whose RBG values are (183, 110, 121), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rose Madder, whose RBG values are (227, 38, 54), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) roseMadderColor;
/*!
* Returns a UIColor object representing the color Rose Madder, whose RBG values are (227, 38, 54), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rose Pink, whose RBG values are (255, 102, 204), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) rosePinkColor;
/*!
* Returns a UIColor object representing the color Rose Pink, whose RBG values are (255, 102, 204), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rose Quartz, whose RBG values are (170, 152, 169), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) roseQuartzColor;
/*!
* Returns a UIColor object representing the color Rose Quartz, whose RBG values are (170, 152, 169), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rose Red, whose RBG values are (194, 30, 86), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) roseRedColor;
/*!
* Returns a UIColor object representing the color Rose Red, whose RBG values are (194, 30, 86), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rose Taupe, whose RBG values are (144, 93, 93), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) roseTaupeColor;
/*!
* Returns a UIColor object representing the color Rose Taupe, whose RBG values are (144, 93, 93), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rose Vale, whose RBG values are (171, 78, 82), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) roseValeColor;
/*!
* Returns a UIColor object representing the color Rose Vale, whose RBG values are (171, 78, 82), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rosewood, whose RBG values are (101, 0, 11), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) rosewoodColor;
/*!
* Returns a UIColor object representing the color Rosewood, whose RBG values are (101, 0, 11), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rosso Corsa, whose RBG values are (212, 0, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) rossoCorsaColor;
/*!
* Returns a UIColor object representing the color Rosso Corsa, whose RBG values are (212, 0, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rosy Brown, whose RBG values are (188, 143, 143), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) rosyBrownColor;
/*!
* Returns a UIColor object representing the color Rosy Brown, whose RBG values are (188, 143, 143), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Royal Purple (Crayola), whose RBG values are (120, 81, 169), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Royal Purple (Crayola), whose RBG values are (120, 81, 169), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Royal Azure, whose RBG values are (0, 56, 168), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) royalAzureColor;
/*!
* Returns a UIColor object representing the color Royal Azure, whose RBG values are (0, 56, 168), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Royal Blue, whose RBG values are (65, 105, 225), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) royalBlueColor;
/*!
* Returns a UIColor object representing the color Royal Blue, whose RBG values are (65, 105, 225), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Royal Blue (Darker), whose RBG values are (0, 35, 102), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Royal Blue (Darker), whose RBG values are (0, 35, 102), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Royal Fuchsia, whose RBG values are (202, 44, 146), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) royalFuchsiaColor;
/*!
* Returns a UIColor object representing the color Royal Fuchsia, whose RBG values are (202, 44, 146), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Royal Yellow, whose RBG values are (250, 218, 94), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) royalYellowColor;
/*!
* Returns a UIColor object representing the color Royal Yellow, whose RBG values are (250, 218, 94), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ruber, whose RBG values are (206, 70, 118), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ruberColor;
/*!
* Returns a UIColor object representing the color Ruber, whose RBG values are (206, 70, 118), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ruberColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rubine Red, whose RBG values are (209, 0, 86), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) rubineRedColor;
/*!
* Returns a UIColor object representing the color Rubine Red, whose RBG values are (209, 0, 86), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ruby, whose RBG values are (224, 17, 95), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) rubyColor;
/*!
* Returns a UIColor object representing the color Ruby, whose RBG values are (224, 17, 95), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) rubyColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ruby Red, whose RBG values are (155, 17, 30), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) rubyRedColor;
/*!
* Returns a UIColor object representing the color Ruby Red, whose RBG values are (155, 17, 30), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ruddy, whose RBG values are (255, 0, 40), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ruddyColor;
/*!
* Returns a UIColor object representing the color Ruddy, whose RBG values are (255, 0, 40), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ruddyColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ruddy Brown, whose RBG values are (187, 101, 40), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ruddyBrownColor;
/*!
* Returns a UIColor object representing the color Ruddy Brown, whose RBG values are (187, 101, 40), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ruddy Pink, whose RBG values are (225, 142, 150), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ruddyPinkColor;
/*!
* Returns a UIColor object representing the color Ruddy Pink, whose RBG values are (225, 142, 150), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rufous, whose RBG values are (168, 28, 7), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) rufousColor;
/*!
* Returns a UIColor object representing the color Rufous, whose RBG values are (168, 28, 7), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Russet, whose RBG values are (128, 70, 27), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) russetColor;
/*!
* Returns a UIColor object representing the color Russet, whose RBG values are (128, 70, 27), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Russian Green, whose RBG values are (103, 146, 103), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) russianGreenColor;
/*!
* Returns a UIColor object representing the color Russian Green, whose RBG values are (103, 146, 103), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Russian Violet, whose RBG values are (50, 23, 77), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) russianVioletColor;
/*!
* Returns a UIColor object representing the color Russian Violet, whose RBG values are (50, 23, 77), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rust, whose RBG values are (183, 65, 14), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) rustColor;
/*!
* Returns a UIColor object representing the color Rust, whose RBG values are (183, 65, 14), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) rustColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Rusty Red, whose RBG values are (218, 44, 67), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) rustyRedColor;
/*!
* Returns a UIColor object representing the color Rusty Red, whose RBG values are (218, 44, 67), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sacramento State Green, whose RBG values are (0, 86, 63), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Sacramento State Green, whose RBG values are (0, 86, 63), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Saddle Brown, whose RBG values are (139, 69, 19), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) saddleBrownColor;
/*!
* Returns a UIColor object representing the color Saddle Brown, whose RBG values are (139, 69, 19), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Safety Orange, whose RBG values are (255, 120, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) safetyOrangeColor;
/*!
* Returns a UIColor object representing the color Safety Orange, whose RBG values are (255, 120, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Safety Orange (Blaze Orange), whose RBG values are (255, 103, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Safety Orange (Blaze Orange), whose RBG values are (255, 103, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Safety Yellow, whose RBG values are (238, 210, 2), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) safetyYellowColor;
/*!
* Returns a UIColor object representing the color Safety Yellow, whose RBG values are (238, 210, 2), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Saffron, whose RBG values are (244, 196, 48), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) saffronColor;
/*!
* Returns a UIColor object representing the color Saffron, whose RBG values are (244, 196, 48), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sage, whose RBG values are (188, 184, 138), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sageColor;
/*!
* Returns a UIColor object representing the color Sage, whose RBG values are (188, 184, 138), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sageColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Salmon, whose RBG values are (250, 128, 114), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) salmonColor;
/*!
* Returns a UIColor object representing the color Salmon, whose RBG values are (250, 128, 114), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Salmon (Crayola), whose RBG values are (255, 155, 170), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) salmonCrayolaColor;
/*!
* Returns a UIColor object representing the color Salmon (Crayola), whose RBG values are (255, 155, 170), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Salmon Pink, whose RBG values are (255, 145, 164), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) salmonPinkColor;
/*!
* Returns a UIColor object representing the color Salmon Pink, whose RBG values are (255, 145, 164), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sand, whose RBG values are (194, 178, 128), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sandColor;
/*!
* Returns a UIColor object representing the color Sand, whose RBG values are (194, 178, 128), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sandColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sand Dune, whose RBG values are (150, 113, 23), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sandDuneColor;
/*!
* Returns a UIColor object representing the color Sand Dune, whose RBG values are (150, 113, 23), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sandstorm, whose RBG values are (236, 213, 64), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sandstormColor;
/*!
* Returns a UIColor object representing the color Sandstorm, whose RBG values are (236, 213, 64), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sandy Brown, whose RBG values are (244, 164, 96), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sandyBrownColor;
/*!
* Returns a UIColor object representing the color Sandy Brown, whose RBG values are (244, 164, 96), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sandy Taupe, whose RBG values are (150, 113, 23), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sandyTaupeColor;
/*!
* Returns a UIColor object representing the color Sandy Taupe, whose RBG values are (150, 113, 23), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sangria, whose RBG values are (146, 0, 10), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sangriaColor;
/*!
* Returns a UIColor object representing the color Sangria, whose RBG values are (146, 0, 10), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sap Green, whose RBG values are (80, 125, 42), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sapGreenColor;
/*!
* Returns a UIColor object representing the color Sap Green, whose RBG values are (80, 125, 42), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sapphire, whose RBG values are (15, 82, 186), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sapphireColor;
/*!
* Returns a UIColor object representing the color Sapphire, whose RBG values are (15, 82, 186), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sapphire Blue, whose RBG values are (0, 103, 165), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sapphireBlueColor;
/*!
* Returns a UIColor object representing the color Sapphire Blue, whose RBG values are (0, 103, 165), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Satin Sheen Gold, whose RBG values are (203, 161, 53), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) satinSheenGoldColor;
/*!
* Returns a UIColor object representing the color Satin Sheen Gold, whose RBG values are (203, 161, 53), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Scarlet, whose RBG values are (255, 36, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) scarletColor;
/*!
* Returns a UIColor object representing the color Scarlet, whose RBG values are (255, 36, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Scarlet (Crayola), whose RBG values are (252, 40, 71), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) scarletCrayolaColor;
/*!
* Returns a UIColor object representing the color Scarlet (Crayola), whose RBG values are (252, 40, 71), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Scarlet (Websafe), whose RBG values are (255, 51, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) scarletWebsafeColor;
/*!
* Returns a UIColor object representing the color Scarlet (Websafe), whose RBG values are (255, 51, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Schauss Pink, whose RBG values are (255, 145, 175), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) schaussPinkColor;
/*!
* Returns a UIColor object representing the color Schauss Pink, whose RBG values are (255, 145, 175), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color School Bus Yellow, whose RBG values are (255, 216, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color School Bus Yellow, whose RBG values are (255, 216, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Screamin' Green (Crayola), whose RBG values are (118, 255, 122), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Screamin' Green (Crayola), whose RBG values are (118, 255, 122), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sea Green (Crayola), whose RBG values are (147, 223, 184), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Sea Green (Crayola), whose RBG values are (147, 223, 184), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sea Blue, whose RBG values are (0, 105, 148), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) seaBlueColor;
/*!
* Returns a UIColor object representing the color Sea Blue, whose RBG values are (0, 105, 148), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sea Green, whose RBG values are (46, 139, 87), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) seaGreenColor;
/*!
* Returns a UIColor object representing the color Sea Green, whose RBG values are (46, 139, 87), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Seal Brown, whose RBG values are (50, 20, 20), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sealBrownColor;
/*!
* Returns a UIColor object representing the color Seal Brown, whose RBG values are (50, 20, 20), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Seashell, whose RBG values are (255, 245, 238), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) seashellColor;
/*!
* Returns a UIColor object representing the color Seashell, whose RBG values are (255, 245, 238), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Selective Yellow, whose RBG values are (255, 186, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Selective Yellow, whose RBG values are (255, 186, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sepia, whose RBG values are (112, 66, 20), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sepiaColor;
/*!
* Returns a UIColor object representing the color Sepia, whose RBG values are (112, 66, 20), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sepiaColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sepia (Crayola), whose RBG values are (165, 105, 79), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sepiaCrayolaColor;
/*!
* Returns a UIColor object representing the color Sepia (Crayola), whose RBG values are (165, 105, 79), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Shadow (Crayola), whose RBG values are (138, 121, 93), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) shadowCrayolaColor;
/*!
* Returns a UIColor object representing the color Shadow (Crayola), whose RBG values are (138, 121, 93), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Shadow Blue, whose RBG values are (119, 139, 165), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) shadowBlueColor;
/*!
* Returns a UIColor object representing the color Shadow Blue, whose RBG values are (119, 139, 165), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Shampoo, whose RBG values are (255, 207, 241), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) shampooColor;
/*!
* Returns a UIColor object representing the color Shampoo, whose RBG values are (255, 207, 241), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Shamrock (Crayola), whose RBG values are (69, 206, 162), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Shamrock (Crayola), whose RBG values are (69, 206, 162), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Shamrock Green, whose RBG values are (0, 158, 96), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) shamrockGreenColor;
/*!
* Returns a UIColor object representing the color Shamrock Green, whose RBG values are (0, 158, 96), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sheen Green, whose RBG values are (143, 212, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sheenGreenColor;
/*!
* Returns a UIColor object representing the color Sheen Green, whose RBG values are (143, 212, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Shimmering Blush, whose RBG values are (217, 134, 149), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Shimmering Blush, whose RBG values are (217, 134, 149), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Shocking Pink (Crayola), whose RBG values are (251, 126, 253), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Shocking Pink (Crayola), whose RBG values are (251, 126, 253), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Shocking Pink, whose RBG values are (252, 15, 192), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) shockingPinkColor;
/*!
* Returns a UIColor object representing the color Shocking Pink, whose RBG values are (252, 15, 192), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sienna, whose RBG values are (136, 45, 23), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) siennaColor;
/*!
* Returns a UIColor object representing the color Sienna, whose RBG values are (136, 45, 23), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sienna (X11), whose RBG values are (160, 82, 45), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) siennaX11Color;
/*!
* Returns a UIColor object representing the color Sienna (X11), whose RBG values are (160, 82, 45), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Silver, whose RBG values are (192, 192, 192), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) silverColor;
/*!
* Returns a UIColor object representing the color Silver, whose RBG values are (192, 192, 192), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Silver (Crayola), whose RBG values are (205, 197, 194), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) silverCrayolaColor;
/*!
* Returns a UIColor object representing the color Silver (Crayola), whose RBG values are (205, 197, 194), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Silver Lake Blue, whose RBG values are (93, 137, 186), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) silverLakeBlueColor;
/*!
* Returns a UIColor object representing the color Silver Lake Blue, whose RBG values are (93, 137, 186), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Silver Chalice, whose RBG values are (172, 172, 172), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) silverChaliceColor;
/*!
* Returns a UIColor object representing the color Silver Chalice, whose RBG values are (172, 172, 172), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Silver Pink, whose RBG values are (196, 174, 173), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) silverPinkColor;
/*!
* Returns a UIColor object representing the color Silver Pink, whose RBG values are (196, 174, 173), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Silver Sand, whose RBG values are (191, 193, 194), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) silverSandColor;
/*!
* Returns a UIColor object representing the color Silver Sand, whose RBG values are (191, 193, 194), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sinopia, whose RBG values are (203, 65, 11), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sinopiaColor;
/*!
* Returns a UIColor object representing the color Sinopia, whose RBG values are (203, 65, 11), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Skobeloff, whose RBG values are (0, 116, 116), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) skobeloffColor;
/*!
* Returns a UIColor object representing the color Skobeloff, whose RBG values are (0, 116, 116), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sky Blue (Crayola), whose RBG values are (128, 218, 235), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) skyBlueCrayolaColor;
/*!
* Returns a UIColor object representing the color Sky Blue (Crayola), whose RBG values are (128, 218, 235), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sky Blue, whose RBG values are (135, 206, 235), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) skyBlueColor;
/*!
* Returns a UIColor object representing the color Sky Blue, whose RBG values are (135, 206, 235), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sky Magenta, whose RBG values are (207, 113, 175), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) skyMagentaColor;
/*!
* Returns a UIColor object representing the color Sky Magenta, whose RBG values are (207, 113, 175), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Slate Blue, whose RBG values are (106, 90, 205), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) slateBlueColor;
/*!
* Returns a UIColor object representing the color Slate Blue, whose RBG values are (106, 90, 205), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Slate Gray, whose RBG values are (112, 128, 144), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) slateGrayColor;
/*!
* Returns a UIColor object representing the color Slate Gray, whose RBG values are (112, 128, 144), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Smalt (Dark Powder Blue), whose RBG values are (0, 51, 153), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Smalt (Dark Powder Blue), whose RBG values are (0, 51, 153), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Smitten, whose RBG values are (200, 65, 134), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) smittenColor;
/*!
* Returns a UIColor object representing the color Smitten, whose RBG values are (200, 65, 134), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Smoke, whose RBG values are (115, 130, 118), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) smokeColor;
/*!
* Returns a UIColor object representing the color Smoke, whose RBG values are (115, 130, 118), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) smokeColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Smoky Topaz, whose RBG values are (147, 61, 65), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) smokyTopazColor;
/*!
* Returns a UIColor object representing the color Smoky Topaz, whose RBG values are (147, 61, 65), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Smoky Black, whose RBG values are (16, 12, 8), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) smokyBlackColor;
/*!
* Returns a UIColor object representing the color Smoky Black, whose RBG values are (16, 12, 8), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Snow, whose RBG values are (255, 250, 250), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) snowColor;
/*!
* Returns a UIColor object representing the color Snow, whose RBG values are (255, 250, 250), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) snowColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Soap, whose RBG values are (206, 200, 239), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) soapColor;
/*!
* Returns a UIColor object representing the color Soap, whose RBG values are (206, 200, 239), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) soapColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Solid Pink, whose RBG values are (137, 56, 67), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) solidPinkColor;
/*!
* Returns a UIColor object representing the color Solid Pink, whose RBG values are (137, 56, 67), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sonic Silver, whose RBG values are (117, 117, 117), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sonicSilverColor;
/*!
* Returns a UIColor object representing the color Sonic Silver, whose RBG values are (117, 117, 117), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Space Cadet, whose RBG values are (29, 41, 81), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) spaceCadetColor;
/*!
* Returns a UIColor object representing the color Space Cadet, whose RBG values are (29, 41, 81), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Spanish Bistre, whose RBG values are (128, 117, 50), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) spanishBistreColor;
/*!
* Returns a UIColor object representing the color Spanish Bistre, whose RBG values are (128, 117, 50), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Spanish Blue, whose RBG values are (0, 112, 184), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) spanishBlueColor;
/*!
* Returns a UIColor object representing the color Spanish Blue, whose RBG values are (0, 112, 184), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Spanish Carmine, whose RBG values are (209, 0, 71), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) spanishCarmineColor;
/*!
* Returns a UIColor object representing the color Spanish Carmine, whose RBG values are (209, 0, 71), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Spanish Crimson, whose RBG values are (229, 26, 76), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) spanishCrimsonColor;
/*!
* Returns a UIColor object representing the color Spanish Crimson, whose RBG values are (229, 26, 76), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Spanish Gray, whose RBG values are (152, 152, 152), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) spanishGrayColor;
/*!
* Returns a UIColor object representing the color Spanish Gray, whose RBG values are (152, 152, 152), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Spanish Green, whose RBG values are (0, 145, 80), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) spanishGreenColor;
/*!
* Returns a UIColor object representing the color Spanish Green, whose RBG values are (0, 145, 80), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Spanish Orange, whose RBG values are (232, 97, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) spanishOrangeColor;
/*!
* Returns a UIColor object representing the color Spanish Orange, whose RBG values are (232, 97, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Spanish Pink, whose RBG values are (247, 191, 190), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) spanishPinkColor;
/*!
* Returns a UIColor object representing the color Spanish Pink, whose RBG values are (247, 191, 190), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Spanish Red, whose RBG values are (230, 0, 38), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) spanishRedColor;
/*!
* Returns a UIColor object representing the color Spanish Red, whose RBG values are (230, 0, 38), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Spanish Sky Blue, whose RBG values are (0, 255, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) spanishSkyBlueColor;
/*!
* Returns a UIColor object representing the color Spanish Sky Blue, whose RBG values are (0, 255, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Spanish Violet, whose RBG values are (76, 40, 130), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) spanishVioletColor;
/*!
* Returns a UIColor object representing the color Spanish Violet, whose RBG values are (76, 40, 130), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Spanish Viridian, whose RBG values are (0, 127, 92), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Spanish Viridian, whose RBG values are (0, 127, 92), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Spartan Crimson, whose RBG values are (158, 19, 22), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) spartanCrimsonColor;
/*!
* Returns a UIColor object representing the color Spartan Crimson, whose RBG values are (158, 19, 22), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Spicy Mix, whose RBG values are (139, 95, 77), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) spicyMixColor;
/*!
* Returns a UIColor object representing the color Spicy Mix, whose RBG values are (139, 95, 77), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Spiro Disco Ball, whose RBG values are (15, 192, 252), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) spiroDiscoBallColor;
/*!
* Returns a UIColor object representing the color Spiro Disco Ball, whose RBG values are (15, 192, 252), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Spring Green (Crayola), whose RBG values are (236, 234, 190), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Spring Green (Crayola), whose RBG values are (236, 234, 190), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Spring Bud, whose RBG values are (167, 252, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) springBudColor;
/*!
* Returns a UIColor object representing the color Spring Bud, whose RBG values are (167, 252, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Spring Green, whose RBG values are (0, 255, 127), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) springGreenColor;
/*!
* Returns a UIColor object representing the color Spring Green, whose RBG values are (0, 255, 127), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color St Patrick's Blue, whose RBG values are (35, 41, 122), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) stPatricksBlueColor;
/*!
* Returns a UIColor object representing the color St Patrick's Blue, whose RBG values are (35, 41, 122), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Star Command Blue, whose RBG values are (0, 123, 184), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Star Command Blue, whose RBG values are (0, 123, 184), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Steel Blue, whose RBG values are (70, 130, 180), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) steelBlueColor;
/*!
* Returns a UIColor object representing the color Steel Blue, whose RBG values are (70, 130, 180), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Steel Pink, whose RBG values are (204, 51, 204), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) steelPinkColor;
/*!
* Returns a UIColor object representing the color Steel Pink, whose RBG values are (204, 51, 204), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Stil De Grain Yellow, whose RBG values are (250, 218, 94), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Stil De Grain Yellow, whose RBG values are (250, 218, 94), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Stizza, whose RBG values are (153, 0, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) stizzaColor;
/*!
* Returns a UIColor object representing the color Stizza, whose RBG values are (153, 0, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Stormcloud, whose RBG values are (79, 102, 106), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) stormcloudColor;
/*!
* Returns a UIColor object representing the color Stormcloud, whose RBG values are (79, 102, 106), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Straw, whose RBG values are (228, 217, 111), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) strawColor;
/*!
* Returns a UIColor object representing the color Straw, whose RBG values are (228, 217, 111), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) strawColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Strawberry, whose RBG values are (252, 90, 141), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) strawberryColor;
/*!
* Returns a UIColor object representing the color Strawberry, whose RBG values are (252, 90, 141), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sunglow, whose RBG values are (255, 204, 51), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sunglowColor;
/*!
* Returns a UIColor object representing the color Sunglow, whose RBG values are (255, 204, 51), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sunglow (Crayola), whose RBG values are (255, 207, 72), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sunglowCrayolaColor;
/*!
* Returns a UIColor object representing the color Sunglow (Crayola), whose RBG values are (255, 207, 72), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sunray, whose RBG values are (227, 171, 87), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sunrayColor;
/*!
* Returns a UIColor object representing the color Sunray, whose RBG values are (227, 171, 87), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sunset, whose RBG values are (250, 214, 165), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) sunsetColor;
/*!
* Returns a UIColor object representing the color Sunset, whose RBG values are (250, 214, 165), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Sunset Orange (Crayola), whose RBG values are (253, 94, 83), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Sunset Orange (Crayola), whose RBG values are (253, 94, 83), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Super Pink, whose RBG values are (207, 107, 169), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) superPinkColor;
/*!
* Returns a UIColor object representing the color Super Pink, whose RBG values are (207, 107, 169), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tan, whose RBG values are (210, 180, 140), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tanColor;
/*!
* Returns a UIColor object representing the color Tan, whose RBG values are (210, 180, 140), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tanColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tan (Crayola), whose RBG values are (250, 167, 108), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tanCrayolaColor;
/*!
* Returns a UIColor object representing the color Tan (Crayola), whose RBG values are (250, 167, 108), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tangelo, whose RBG values are (249, 77, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tangeloColor;
/*!
* Returns a UIColor object representing the color Tangelo, whose RBG values are (249, 77, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tangerine, whose RBG values are (242, 133, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tangerineColor;
/*!
* Returns a UIColor object representing the color Tangerine, whose RBG values are (242, 133, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tangerine Yellow, whose RBG values are (255, 204, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Tangerine Yellow, whose RBG values are (255, 204, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tango Pink, whose RBG values are (228, 113, 122), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tangoPinkColor;
/*!
* Returns a UIColor object representing the color Tango Pink, whose RBG values are (228, 113, 122), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Taupe, whose RBG values are (72, 60, 50), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) taupeColor;
/*!
* Returns a UIColor object representing the color Taupe, whose RBG values are (72, 60, 50), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) taupeColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Taupe Gray, whose RBG values are (139, 133, 137), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) taupeGrayColor;
/*!
* Returns a UIColor object representing the color Taupe Gray, whose RBG values are (139, 133, 137), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tea Green, whose RBG values are (208, 240, 192), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) teaGreenColor;
/*!
* Returns a UIColor object representing the color Tea Green, whose RBG values are (208, 240, 192), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tea Rose, whose RBG values are (248, 131, 121), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) teaRoseColor;
/*!
* Returns a UIColor object representing the color Tea Rose, whose RBG values are (248, 131, 121), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tea Rose (Alternate), whose RBG values are (244, 194, 194), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Tea Rose (Alternate), whose RBG values are (244, 194, 194), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Teal, whose RBG values are (0, 128, 128), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tealColor;
/*!
* Returns a UIColor object representing the color Teal, whose RBG values are (0, 128, 128), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tealColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Teal 100, whose RBG values are (178, 223, 219), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) teal100Color;
/*!
* Returns a UIColor object representing the color Teal 100, whose RBG values are (178, 223, 219), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Teal 200, whose RBG values are (128, 203, 196), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) teal200Color;
/*!
* Returns a UIColor object representing the color Teal 200, whose RBG values are (128, 203, 196), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Teal 300, whose RBG values are (77, 182, 172), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) teal300Color;
/*!
* Returns a UIColor object representing the color Teal 300, whose RBG values are (77, 182, 172), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Teal 400, whose RBG values are (38, 166, 154), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) teal400Color;
/*!
* Returns a UIColor object representing the color Teal 400, whose RBG values are (38, 166, 154), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Teal 50, whose RBG values are (224, 242, 241), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) teal50Color;
/*!
* Returns a UIColor object representing the color Teal 50, whose RBG values are (224, 242, 241), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Teal 500, whose RBG values are (0, 150, 136), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) teal500Color;
/*!
* Returns a UIColor object representing the color Teal 500, whose RBG values are (0, 150, 136), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Teal 600, whose RBG values are (0, 137, 123), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) teal600Color;
/*!
* Returns a UIColor object representing the color Teal 600, whose RBG values are (0, 137, 123), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Teal 700, whose RBG values are (0, 121, 107), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) teal700Color;
/*!
* Returns a UIColor object representing the color Teal 700, whose RBG values are (0, 121, 107), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Teal 800, whose RBG values are (0, 105, 92), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) teal800Color;
/*!
* Returns a UIColor object representing the color Teal 800, whose RBG values are (0, 105, 92), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Teal 900, whose RBG values are (0, 77, 64), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) teal900Color;
/*!
* Returns a UIColor object representing the color Teal 900, whose RBG values are (0, 77, 64), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Teal A100, whose RBG values are (167, 255, 235), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tealA100Color;
/*!
* Returns a UIColor object representing the color Teal A100, whose RBG values are (167, 255, 235), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Teal A200, whose RBG values are (100, 255, 218), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tealA200Color;
/*!
* Returns a UIColor object representing the color Teal A200, whose RBG values are (100, 255, 218), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Teal A400, whose RBG values are (29, 233, 182), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tealA400Color;
/*!
* Returns a UIColor object representing the color Teal A400, whose RBG values are (29, 233, 182), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Teal A700, whose RBG values are (0, 191, 165), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tealA700Color;
/*!
* Returns a UIColor object representing the color Teal A700, whose RBG values are (0, 191, 165), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Teal Blue (Crayola), whose RBG values are (24, 167, 181), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Teal Blue (Crayola), whose RBG values are (24, 167, 181), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Teal Blue, whose RBG values are (54, 117, 136), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tealBlueColor;
/*!
* Returns a UIColor object representing the color Teal Blue, whose RBG values are (54, 117, 136), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Teal Deer, whose RBG values are (153, 230, 179), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tealDeerColor;
/*!
* Returns a UIColor object representing the color Teal Deer, whose RBG values are (153, 230, 179), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Teal Green, whose RBG values are (0, 130, 127), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tealGreenColor;
/*!
* Returns a UIColor object representing the color Teal Green, whose RBG values are (0, 130, 127), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Telemagenta, whose RBG values are (207, 52, 118), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) telemagentaColor;
/*!
* Returns a UIColor object representing the color Telemagenta, whose RBG values are (207, 52, 118), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
+ (UIColor *) tennéColor;
+ (UIColor *) tennéColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Terra Cotta, whose RBG values are (226, 114, 91), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) terraCottaColor;
/*!
* Returns a UIColor object representing the color Terra Cotta, whose RBG values are (226, 114, 91), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Thistle, whose RBG values are (216, 191, 216), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) thistleColor;
/*!
* Returns a UIColor object representing the color Thistle, whose RBG values are (216, 191, 216), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Thistle (Crayola), whose RBG values are (235, 199, 223), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) thistleCrayolaColor;
/*!
* Returns a UIColor object representing the color Thistle (Crayola), whose RBG values are (235, 199, 223), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Thulian Pink, whose RBG values are (222, 111, 161), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) thulianPinkColor;
/*!
* Returns a UIColor object representing the color Thulian Pink, whose RBG values are (222, 111, 161), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tickle Me Pink (Crayola), whose RBG values are (252, 137, 172), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Tickle Me Pink (Crayola), whose RBG values are (252, 137, 172), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tiffany Blue, whose RBG values are (10, 186, 181), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tiffanyBlueColor;
/*!
* Returns a UIColor object representing the color Tiffany Blue, whose RBG values are (10, 186, 181), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tiffany Blue (Alternate), whose RBG values are (129, 216, 208), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Tiffany Blue (Alternate), whose RBG values are (129, 216, 208), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tiger's Eye, whose RBG values are (224, 141, 60), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tigersEyeColor;
/*!
* Returns a UIColor object representing the color Tiger's Eye, whose RBG values are (224, 141, 60), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Timberwolf (Crayola), whose RBG values are (219, 215, 210), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Timberwolf (Crayola), whose RBG values are (219, 215, 210), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Titanium Yellow, whose RBG values are (238, 230, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) titaniumYellowColor;
/*!
* Returns a UIColor object representing the color Titanium Yellow, whose RBG values are (238, 230, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tomato, whose RBG values are (255, 99, 71), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tomatoColor;
/*!
* Returns a UIColor object representing the color Tomato, whose RBG values are (255, 99, 71), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Toolbox, whose RBG values are (116, 108, 192), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) toolboxColor;
/*!
* Returns a UIColor object representing the color Toolbox, whose RBG values are (116, 108, 192), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Topaz, whose RBG values are (255, 200, 124), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) topazColor;
/*!
* Returns a UIColor object representing the color Topaz, whose RBG values are (255, 200, 124), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) topazColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tractor Red, whose RBG values are (253, 14, 53), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tractorRedColor;
/*!
* Returns a UIColor object representing the color Tractor Red, whose RBG values are (253, 14, 53), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Trolley Grey, whose RBG values are (128, 128, 128), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) trolleyGreyColor;
/*!
* Returns a UIColor object representing the color Trolley Grey, whose RBG values are (128, 128, 128), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tropical Rain Forest (Crayola), whose RBG values are (23, 128, 109), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Tropical Rain Forest (Crayola), whose RBG values are (23, 128, 109), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tropical Rain Forest, whose RBG values are (0, 117, 94), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Tropical Rain Forest, whose RBG values are (0, 117, 94), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color True Blue, whose RBG values are (0, 115, 207), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) trueBlueColor;
/*!
* Returns a UIColor object representing the color True Blue, whose RBG values are (0, 115, 207), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tufts Blue, whose RBG values are (65, 125, 193), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tuftsBlueColor;
/*!
* Returns a UIColor object representing the color Tufts Blue, whose RBG values are (65, 125, 193), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tulip, whose RBG values are (255, 135, 141), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tulipColor;
/*!
* Returns a UIColor object representing the color Tulip, whose RBG values are (255, 135, 141), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tulipColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tumbleweed (Crayola), whose RBG values are (222, 170, 136), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Tumbleweed (Crayola), whose RBG values are (222, 170, 136), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Turkish Rose, whose RBG values are (181, 114, 129), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) turkishRoseColor;
/*!
* Returns a UIColor object representing the color Turkish Rose, whose RBG values are (181, 114, 129), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Turquoise, whose RBG values are (64, 224, 208), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) turquoiseColor;
/*!
* Returns a UIColor object representing the color Turquoise, whose RBG values are (64, 224, 208), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Turquoise Blue (Crayola), whose RBG values are (119, 221, 231), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Turquoise Blue (Crayola), whose RBG values are (119, 221, 231), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Turquoise Blue, whose RBG values are (0, 255, 239), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) turquoiseBlueColor;
/*!
* Returns a UIColor object representing the color Turquoise Blue, whose RBG values are (0, 255, 239), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Turquoise Green, whose RBG values are (160, 214, 180), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) turquoiseGreenColor;
/*!
* Returns a UIColor object representing the color Turquoise Green, whose RBG values are (160, 214, 180), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tuscan, whose RBG values are (250, 214, 165), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tuscanColor;
/*!
* Returns a UIColor object representing the color Tuscan, whose RBG values are (250, 214, 165), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tuscan Brown, whose RBG values are (111, 78, 55), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tuscanBrownColor;
/*!
* Returns a UIColor object representing the color Tuscan Brown, whose RBG values are (111, 78, 55), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tuscan Red, whose RBG values are (124, 72, 72), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tuscanRedColor;
/*!
* Returns a UIColor object representing the color Tuscan Red, whose RBG values are (124, 72, 72), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tuscan Tan, whose RBG values are (166, 123, 91), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tuscanTanColor;
/*!
* Returns a UIColor object representing the color Tuscan Tan, whose RBG values are (166, 123, 91), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tuscany, whose RBG values are (192, 153, 153), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tuscanyColor;
/*!
* Returns a UIColor object representing the color Tuscany, whose RBG values are (192, 153, 153), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Twilight Lavender, whose RBG values are (138, 73, 107), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Twilight Lavender, whose RBG values are (138, 73, 107), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Tyrian Purple, whose RBG values are (102, 2, 60), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) tyrianPurpleColor;
/*!
* Returns a UIColor object representing the color Tyrian Purple, whose RBG values are (102, 2, 60), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color UA Blue, whose RBG values are (0, 51, 170), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) uABlueColor;
/*!
* Returns a UIColor object representing the color UA Blue, whose RBG values are (0, 51, 170), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color UA Red, whose RBG values are (217, 0, 76), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) uARedColor;
/*!
* Returns a UIColor object representing the color UA Red, whose RBG values are (217, 0, 76), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) uARedColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color UCLA Blue, whose RBG values are (83, 104, 149), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) uCLABlueColor;
/*!
* Returns a UIColor object representing the color UCLA Blue, whose RBG values are (83, 104, 149), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color UCLA Gold, whose RBG values are (255, 179, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) uCLAGoldColor;
/*!
* Returns a UIColor object representing the color UCLA Gold, whose RBG values are (255, 179, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color UFO Green, whose RBG values are (60, 208, 112), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) uFOGreenColor;
/*!
* Returns a UIColor object representing the color UFO Green, whose RBG values are (60, 208, 112), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color UP Forest Green, whose RBG values are (1, 68, 33), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) uPForestGreenColor;
/*!
* Returns a UIColor object representing the color UP Forest Green, whose RBG values are (1, 68, 33), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color UP Maroon, whose RBG values are (123, 17, 19), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) uPMaroonColor;
/*!
* Returns a UIColor object representing the color UP Maroon, whose RBG values are (123, 17, 19), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color USAFA Blue, whose RBG values are (0, 79, 152), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) uSAFABlueColor;
/*!
* Returns a UIColor object representing the color USAFA Blue, whose RBG values are (0, 79, 152), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color USC Cardinal, whose RBG values are (153, 0, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) uSCCardinalColor;
/*!
* Returns a UIColor object representing the color USC Cardinal, whose RBG values are (153, 0, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color USC Gold, whose RBG values are (255, 204, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) uSCGoldColor;
/*!
* Returns a UIColor object representing the color USC Gold, whose RBG values are (255, 204, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ube, whose RBG values are (136, 120, 195), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ubeColor;
/*!
* Returns a UIColor object representing the color Ube, whose RBG values are (136, 120, 195), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ubeColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ultra Pink, whose RBG values are (255, 111, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ultraPinkColor;
/*!
* Returns a UIColor object representing the color Ultra Pink, whose RBG values are (255, 111, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ultra Red, whose RBG values are (252, 108, 133), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ultraRedColor;
/*!
* Returns a UIColor object representing the color Ultra Red, whose RBG values are (252, 108, 133), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ultramarine, whose RBG values are (18, 10, 143), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) ultramarineColor;
/*!
* Returns a UIColor object representing the color Ultramarine, whose RBG values are (18, 10, 143), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Ultramarine Blue, whose RBG values are (65, 102, 245), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Ultramarine Blue, whose RBG values are (65, 102, 245), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Umber, whose RBG values are (99, 81, 71), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) umberColor;
/*!
* Returns a UIColor object representing the color Umber, whose RBG values are (99, 81, 71), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) umberColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Unbleached Silk, whose RBG values are (255, 221, 202), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) unbleachedSilkColor;
/*!
* Returns a UIColor object representing the color Unbleached Silk, whose RBG values are (255, 221, 202), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color United Nations Blue, whose RBG values are (91, 146, 229), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color United Nations Blue, whose RBG values are (91, 146, 229), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color University Of California Gold, whose RBG values are (183, 135, 39), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color University Of California Gold, whose RBG values are (183, 135, 39), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color University Of Tennessee Orange, whose RBG values are (247, 127, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color University Of Tennessee Orange, whose RBG values are (247, 127, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Unmellow Yellow (Crayola), whose RBG values are (255, 255, 102), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Unmellow Yellow (Crayola), whose RBG values are (255, 255, 102), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Upsdell Red, whose RBG values are (174, 32, 41), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) upsdellRedColor;
/*!
* Returns a UIColor object representing the color Upsdell Red, whose RBG values are (174, 32, 41), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Urobilin, whose RBG values are (225, 173, 33), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) urobilinColor;
/*!
* Returns a UIColor object representing the color Urobilin, whose RBG values are (225, 173, 33), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Utah Crimson, whose RBG values are (211, 0, 63), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) utahCrimsonColor;
/*!
* Returns a UIColor object representing the color Utah Crimson, whose RBG values are (211, 0, 63), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vanilla, whose RBG values are (243, 229, 171), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vanillaColor;
/*!
* Returns a UIColor object representing the color Vanilla, whose RBG values are (243, 229, 171), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vanilla Ice, whose RBG values are (243, 143, 169), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vanillaIceColor;
/*!
* Returns a UIColor object representing the color Vanilla Ice, whose RBG values are (243, 143, 169), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vegas Gold, whose RBG values are (197, 179, 88), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vegasGoldColor;
/*!
* Returns a UIColor object representing the color Vegas Gold, whose RBG values are (197, 179, 88), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Venetian Red, whose RBG values are (200, 8, 21), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) venetianRedColor;
/*!
* Returns a UIColor object representing the color Venetian Red, whose RBG values are (200, 8, 21), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Verdigris, whose RBG values are (67, 179, 174), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) verdigrisColor;
/*!
* Returns a UIColor object representing the color Verdigris, whose RBG values are (67, 179, 174), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vermilion, whose RBG values are (227, 66, 52), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vermilionColor;
/*!
* Returns a UIColor object representing the color Vermilion, whose RBG values are (227, 66, 52), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vermilion (Alternate), whose RBG values are (217, 56, 30), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Vermilion (Alternate), whose RBG values are (217, 56, 30), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Veronica, whose RBG values are (160, 32, 240), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) veronicaColor;
/*!
* Returns a UIColor object representing the color Veronica, whose RBG values are (160, 32, 240), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Very Light Azure, whose RBG values are (116, 187, 251), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) veryLightAzureColor;
/*!
* Returns a UIColor object representing the color Very Light Azure, whose RBG values are (116, 187, 251), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Very Light Blue, whose RBG values are (102, 102, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) veryLightBlueColor;
/*!
* Returns a UIColor object representing the color Very Light Blue, whose RBG values are (102, 102, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Very Light Malachite Green, whose RBG values are (100, 233, 134), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Very Light Malachite Green, whose RBG values are (100, 233, 134), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Very Light Tangelo, whose RBG values are (255, 176, 119), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Very Light Tangelo, whose RBG values are (255, 176, 119), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Very Pale Orange, whose RBG values are (255, 223, 191), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) veryPaleOrangeColor;
/*!
* Returns a UIColor object representing the color Very Pale Orange, whose RBG values are (255, 223, 191), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Very Pale Yellow, whose RBG values are (255, 255, 191), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) veryPaleYellowColor;
/*!
* Returns a UIColor object representing the color Very Pale Yellow, whose RBG values are (255, 255, 191), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Violet, whose RBG values are (143, 0, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) violetColor;
/*!
* Returns a UIColor object representing the color Violet, whose RBG values are (143, 0, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Violet (Color Wheel), whose RBG values are (127, 0, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Violet (Color Wheel), whose RBG values are (127, 0, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Violet (Purple) (Crayola), whose RBG values are (146, 110, 174), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Violet (Purple) (Crayola), whose RBG values are (146, 110, 174), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Violet (RYB), whose RBG values are (134, 1, 175), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) violetRYBColor;
/*!
* Returns a UIColor object representing the color Violet (RYB), whose RBG values are (134, 1, 175), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Violet (Web), whose RBG values are (238, 130, 238), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) violetWebColor;
/*!
* Returns a UIColor object representing the color Violet (Web), whose RBG values are (238, 130, 238), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Violet Blue (Crayola), whose RBG values are (50, 74, 178), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Violet Blue (Crayola), whose RBG values are (50, 74, 178), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Violet Red (Crayola), whose RBG values are (247, 83, 148), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Violet Red (Crayola), whose RBG values are (247, 83, 148), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Viridian, whose RBG values are (64, 130, 109), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) viridianColor;
/*!
* Returns a UIColor object representing the color Viridian, whose RBG values are (64, 130, 109), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Viridian Green, whose RBG values are (0, 150, 152), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) viridianGreenColor;
/*!
* Returns a UIColor object representing the color Viridian Green, whose RBG values are (0, 150, 152), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vista Blue, whose RBG values are (124, 158, 217), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vistaBlueColor;
/*!
* Returns a UIColor object representing the color Vista Blue, whose RBG values are (124, 158, 217), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Tangerine (Crayola), whose RBG values are (255, 160, 137), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Vivid Tangerine (Crayola), whose RBG values are (255, 160, 137), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Violet (Crayola), whose RBG values are (143, 80, 157), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Vivid Violet (Crayola), whose RBG values are (143, 80, 157), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Amber, whose RBG values are (204, 153, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vividAmberColor;
/*!
* Returns a UIColor object representing the color Vivid Amber, whose RBG values are (204, 153, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Auburn, whose RBG values are (146, 39, 36), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vividAuburnColor;
/*!
* Returns a UIColor object representing the color Vivid Auburn, whose RBG values are (146, 39, 36), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Burgundy, whose RBG values are (159, 29, 53), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vividBurgundyColor;
/*!
* Returns a UIColor object representing the color Vivid Burgundy, whose RBG values are (159, 29, 53), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Cerise, whose RBG values are (218, 29, 129), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vividCeriseColor;
/*!
* Returns a UIColor object representing the color Vivid Cerise, whose RBG values are (218, 29, 129), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Cerulean, whose RBG values are (0, 170, 238), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vividCeruleanColor;
/*!
* Returns a UIColor object representing the color Vivid Cerulean, whose RBG values are (0, 170, 238), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Crimson, whose RBG values are (204, 0, 51), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vividCrimsonColor;
/*!
* Returns a UIColor object representing the color Vivid Crimson, whose RBG values are (204, 0, 51), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Gamboge, whose RBG values are (255, 153, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vividGambogeColor;
/*!
* Returns a UIColor object representing the color Vivid Gamboge, whose RBG values are (255, 153, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Lime Green, whose RBG values are (166, 214, 8), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vividLimeGreenColor;
/*!
* Returns a UIColor object representing the color Vivid Lime Green, whose RBG values are (166, 214, 8), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Malachite, whose RBG values are (0, 204, 51), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vividMalachiteColor;
/*!
* Returns a UIColor object representing the color Vivid Malachite, whose RBG values are (0, 204, 51), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Mulberry, whose RBG values are (184, 12, 227), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vividMulberryColor;
/*!
* Returns a UIColor object representing the color Vivid Mulberry, whose RBG values are (184, 12, 227), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Orange, whose RBG values are (255, 95, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vividOrangeColor;
/*!
* Returns a UIColor object representing the color Vivid Orange, whose RBG values are (255, 95, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Orange Peel, whose RBG values are (255, 160, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Vivid Orange Peel, whose RBG values are (255, 160, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Orchid, whose RBG values are (204, 0, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vividOrchidColor;
/*!
* Returns a UIColor object representing the color Vivid Orchid, whose RBG values are (204, 0, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Raspberry, whose RBG values are (255, 0, 108), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vividRaspberryColor;
/*!
* Returns a UIColor object representing the color Vivid Raspberry, whose RBG values are (255, 0, 108), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Red, whose RBG values are (247, 13, 26), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vividRedColor;
/*!
* Returns a UIColor object representing the color Vivid Red, whose RBG values are (247, 13, 26), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Red-Tangelo, whose RBG values are (223, 97, 36), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Vivid Red-Tangelo, whose RBG values are (223, 97, 36), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Sky Blue, whose RBG values are (0, 204, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vividSkyBlueColor;
/*!
* Returns a UIColor object representing the color Vivid Sky Blue, whose RBG values are (0, 204, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Tangelo, whose RBG values are (240, 116, 39), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vividTangeloColor;
/*!
* Returns a UIColor object representing the color Vivid Tangelo, whose RBG values are (240, 116, 39), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Vermilion, whose RBG values are (229, 96, 36), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vividVermilionColor;
/*!
* Returns a UIColor object representing the color Vivid Vermilion, whose RBG values are (229, 96, 36), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Violet, whose RBG values are (159, 0, 255), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vividVioletColor;
/*!
* Returns a UIColor object representing the color Vivid Violet, whose RBG values are (159, 0, 255), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Vivid Yellow, whose RBG values are (255, 227, 2), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) vividYellowColor;
/*!
* Returns a UIColor object representing the color Vivid Yellow, whose RBG values are (255, 227, 2), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Volt, whose RBG values are (205, 255, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) voltColor;
/*!
* Returns a UIColor object representing the color Volt, whose RBG values are (205, 255, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) voltColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Warm Black, whose RBG values are (0, 66, 66), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) warmBlackColor;
/*!
* Returns a UIColor object representing the color Warm Black, whose RBG values are (0, 66, 66), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Waterspout, whose RBG values are (164, 244, 249), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) waterspoutColor;
/*!
* Returns a UIColor object representing the color Waterspout, whose RBG values are (164, 244, 249), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Web Gray, whose RBG values are (128, 128, 128), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) webGrayColor;
/*!
* Returns a UIColor object representing the color Web Gray, whose RBG values are (128, 128, 128), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Web Green, whose RBG values are (0, 128, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) webGreenColor;
/*!
* Returns a UIColor object representing the color Web Green, whose RBG values are (0, 128, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Web Maroon, whose RBG values are (127, 0, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) webMaroonColor;
/*!
* Returns a UIColor object representing the color Web Maroon, whose RBG values are (127, 0, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Web Purple, whose RBG values are (127, 0, 127), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) webPurpleColor;
/*!
* Returns a UIColor object representing the color Web Purple, whose RBG values are (127, 0, 127), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Wenge, whose RBG values are (100, 84, 82), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) wengeColor;
/*!
* Returns a UIColor object representing the color Wenge, whose RBG values are (100, 84, 82), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) wengeColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Wheat, whose RBG values are (245, 222, 179), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) wheatColor;
/*!
* Returns a UIColor object representing the color Wheat, whose RBG values are (245, 222, 179), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) wheatColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color White Smoke, whose RBG values are (245, 245, 245), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) whiteSmokeColor;
/*!
* Returns a UIColor object representing the color White Smoke, whose RBG values are (245, 245, 245), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Wild Blue Yonder (Crayola), whose RBG values are (162, 173, 208), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Wild Blue Yonder (Crayola), whose RBG values are (162, 173, 208), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Wild Strawberry (Crayola), whose RBG values are (255, 67, 164), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Wild Strawberry (Crayola), whose RBG values are (255, 67, 164), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Wild Watermelon (Crayola), whose RBG values are (252, 108, 133), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Wild Watermelon (Crayola), whose RBG values are (252, 108, 133), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Wild Orchid, whose RBG values are (212, 112, 162), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) wildOrchidColor;
/*!
* Returns a UIColor object representing the color Wild Orchid, whose RBG values are (212, 112, 162), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Willpower Orange, whose RBG values are (253, 88, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Willpower Orange, whose RBG values are (253, 88, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Windsor Tan, whose RBG values are (167, 85, 2), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) windsorTanColor;
/*!
* Returns a UIColor object representing the color Windsor Tan, whose RBG values are (167, 85, 2), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Wine, whose RBG values are (114, 47, 55), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) wineColor;
/*!
* Returns a UIColor object representing the color Wine, whose RBG values are (114, 47, 55), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) wineColorWithAlpha:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Wine Dregs, whose RBG values are (103, 49, 71), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) wineDregsColor;
/*!
* Returns a UIColor object representing the color Wine Dregs, whose RBG values are (103, 49, 71), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Wisteria, whose RBG values are (201, 160, 220), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) wisteriaColor;
/*!
* Returns a UIColor object representing the color Wisteria, whose RBG values are (201, 160, 220), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Wisteria (Crayola), whose RBG values are (205, 164, 222), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Wisteria (Crayola), whose RBG values are (205, 164, 222), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Wood Brown, whose RBG values are (193, 154, 107), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) woodBrownColor;
/*!
* Returns a UIColor object representing the color Wood Brown, whose RBG values are (193, 154, 107), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Xanadu, whose RBG values are (115, 134, 120), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) xanaduColor;
/*!
* Returns a UIColor object representing the color Xanadu, whose RBG values are (115, 134, 120), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yale Blue, whose RBG values are (15, 77, 146), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yaleBlueColor;
/*!
* Returns a UIColor object representing the color Yale Blue, whose RBG values are (15, 77, 146), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yankees Blue, whose RBG values are (28, 40, 65), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yankeesBlueColor;
/*!
* Returns a UIColor object representing the color Yankees Blue, whose RBG values are (28, 40, 65), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow (Crayola), whose RBG values are (252, 232, 131), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yellowCrayolaColor;
/*!
* Returns a UIColor object representing the color Yellow (Crayola), whose RBG values are (252, 232, 131), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow (Munsell), whose RBG values are (239, 204, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yellowMunsellColor;
/*!
* Returns a UIColor object representing the color Yellow (Munsell), whose RBG values are (239, 204, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow (NCS), whose RBG values are (255, 211, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yellowNCSColor;
/*!
* Returns a UIColor object representing the color Yellow (NCS), whose RBG values are (255, 211, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow (Pantone), whose RBG values are (254, 223, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yellowPantoneColor;
/*!
* Returns a UIColor object representing the color Yellow (Pantone), whose RBG values are (254, 223, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow (Process), whose RBG values are (255, 239, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yellowProcessColor;
/*!
* Returns a UIColor object representing the color Yellow (Process), whose RBG values are (255, 239, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow (RYB), whose RBG values are (254, 254, 51), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yellowRYBColor;
/*!
* Returns a UIColor object representing the color Yellow (RYB), whose RBG values are (254, 254, 51), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow 100, whose RBG values are (255, 249, 196), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yellow100Color;
/*!
* Returns a UIColor object representing the color Yellow 100, whose RBG values are (255, 249, 196), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow 200, whose RBG values are (255, 245, 157), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yellow200Color;
/*!
* Returns a UIColor object representing the color Yellow 200, whose RBG values are (255, 245, 157), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow 300, whose RBG values are (255, 241, 118), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yellow300Color;
/*!
* Returns a UIColor object representing the color Yellow 300, whose RBG values are (255, 241, 118), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow 400, whose RBG values are (255, 238, 88), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yellow400Color;
/*!
* Returns a UIColor object representing the color Yellow 400, whose RBG values are (255, 238, 88), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow 50, whose RBG values are (255, 253, 231), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yellow50Color;
/*!
* Returns a UIColor object representing the color Yellow 50, whose RBG values are (255, 253, 231), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow 500, whose RBG values are (255, 235, 59), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yellow500Color;
/*!
* Returns a UIColor object representing the color Yellow 500, whose RBG values are (255, 235, 59), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow 600, whose RBG values are (253, 216, 53), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yellow600Color;
/*!
* Returns a UIColor object representing the color Yellow 600, whose RBG values are (253, 216, 53), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow 700, whose RBG values are (251, 192, 45), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yellow700Color;
/*!
* Returns a UIColor object representing the color Yellow 700, whose RBG values are (251, 192, 45), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow 800, whose RBG values are (249, 168, 37), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yellow800Color;
/*!
* Returns a UIColor object representing the color Yellow 800, whose RBG values are (249, 168, 37), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow 900, whose RBG values are (245, 127, 23), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yellow900Color;
/*!
* Returns a UIColor object representing the color Yellow 900, whose RBG values are (245, 127, 23), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow A100, whose RBG values are (255, 255, 141), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yellowA100Color;
/*!
* Returns a UIColor object representing the color Yellow A100, whose RBG values are (255, 255, 141), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow A200, whose RBG values are (255, 255, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yellowA200Color;
/*!
* Returns a UIColor object representing the color Yellow A200, whose RBG values are (255, 255, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow A400, whose RBG values are (255, 234, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yellowA400Color;
/*!
* Returns a UIColor object representing the color Yellow A400, whose RBG values are (255, 234, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow A700, whose RBG values are (255, 214, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yellowA700Color;
/*!
* Returns a UIColor object representing the color Yellow A700, whose RBG values are (255, 214, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow Green (Crayola), whose RBG values are (197, 227, 132), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Yellow Green (Crayola), whose RBG values are (197, 227, 132), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow Orange (Crayola), whose RBG values are (255, 174, 66), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Yellow Orange (Crayola), whose RBG values are (255, 174, 66), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow Green, whose RBG values are (154, 205, 50), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yellowGreenColor;
/*!
* Returns a UIColor object representing the color Yellow Green, whose RBG values are (154, 205, 50), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Yellow Rose, whose RBG values are (255, 240, 0), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) yellowRoseColor;
/*!
* Returns a UIColor object representing the color Yellow Rose, whose RBG values are (255, 240, 0), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Zaffre, whose RBG values are (0, 20, 168), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) zaffreColor;
/*!
* Returns a UIColor object representing the color Zaffre, whose RBG values are (0, 20, 168), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Zinnwaldite Brown, whose RBG values are (44, 22, 8), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>;
/*!
* Returns a UIColor object representing the color Zinnwaldite Brown, whose RBG values are (44, 22, 8), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) <API key>:(CGFloat) alpha;
/*!
* Returns a UIColor object representing the color Zomp, whose RBG values are (57, 167, 142), and has an opacity of 1.0.
* @return The UIColor object
*/
+ (UIColor *) zompColor;
/*!
* Returns a UIColor object representing the color Zomp, whose RBG values are (57, 167, 142), and has the specified opacity.
* @param alpha A CGFloat between 0.0 and 1.0 representing the opacity with a default value of 1.0.
* @return The UIColor object
*/
+ (UIColor *) zompColorWithAlpha:(CGFloat) alpha;
@end
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.