Icons

Design

Icons are an important communication device that are used as short hand to indicate status, support text labels, or as the sole identifier of common functions. Not all icons are the same colour.

Icon Set

Code

Actions

Icon Summary Code
Collapse all
Name:
Collapse all
Template glyph key:
action-collapseall
Use case:
Collapse all items in set, eg. an index element
 
<span class="ace-icon ace-icon-action-collapseall">Collapse all</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "action-collapseall",_
                                                                                                                        "text", "Collapse all"_
                                                                                                                      ))
Expand all
Name:
Expand all
Template glyph key:
action-expandall
Use case:
Expand all items in a set, eg. an index element
 
<span class="ace-icon ace-icon-action-expandall">Expand all</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "action-expandall",_
                                                                                                                        "text", "Expand all"_
                                                                                                                      ))
Archive
Name:
Archive
Template glyph key:
action-archive
Use case:
Customer archive
 
<span class="ace-icon ace-icon-action-archive">Archive</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "action-archive",_
                                                                                                                        "text", "Archive"_
                                                                                                                      ))
Download
Name:
Download
Template glyph key:
action-download
Use case:
Download in bulk
 
<span class="ace-icon ace-icon-action-download">Download</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "action-download",_
                                                                                                                        "text", "Download"_
                                                                                                                      ))
Upload
Name:
Upload
Template glyph key:
action-upload
Use case:
Upload in bulk
 
<span class="ace-icon ace-icon-action-upload">Upload</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "action-upload",_
                                                                                                                        "text", "Upload"_
                                                                                                                      ))
Edit
Name:
Edit
Template glyph key:
action-edit
Use case:
Edit a document or folder
 
<span class="ace-icon ace-icon-action-edit">Edit</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "action-edit",_
                                                                                                                        "text", "Edit"_
                                                                                                                      ))
Disable
Name:
Disable
Template glyph key:
action-disable
Use case:
Disable a document or folder
 
<span class="ace-icon ace-icon-action-disable">Disable</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "action-disable",_
                                                                                                                        "text", "Disable"_
                                                                                                                      ))
Enable
Name:
Enable
Template glyph key:
action-enable
Use case:
Enable a document or folder
 
<span class="ace-icon ace-icon-action-enable">Enable</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "action-enable",_
                                                                                                                        "text", "Enable"_
                                                                                                                      ))
Copy
Name:
Copy
Template glyph key:
action-copy
Use case:
Copy a document or folder (note the icon does look the same as Move, but ensure you use the correct icon for copy actions)
 
<span class="ace-icon ace-icon-action-copy">Copy</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "action-copy",_
                                                                                                                        "text", "Copy"_
                                                                                                                      ))
Move
Name:
Move
Template glyph key:
action-move
Use case:
Move a document or folder
 
<span class="ace-icon ace-icon-action-move">Move</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "action-move",_
                                                                                                                        "text", "Move"_
                                                                                                                      ))
Number
Name:
Number
Template glyph key:
action-number
Use case:
Renumber a document or folder
 
<span class="ace-icon ace-icon-action-number">Number</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "action-number",_
                                                                                                                        "text", "Number"_
                                                                                                                      ))
Bulk email
Name:
Bulk email
Template glyph key:
action-bulkemail
Use case:
Send emails in bulk
 
<span class="ace-icon ace-icon-action-bulkemail">Bulk email</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "action-bulkemail",_
                                                                                                                        "text", "Bulk email"_
                                                                                                                      ))
Send invidation
Name:
Send invidation
Template glyph key:
action-sendinvite
Use case:
Send data room invites
 
<span class="ace-icon ace-icon-action-sendinvite">Send invidation</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "action-sendinvite",_
                                                                                                                        "text", "Send invidation"_
                                                                                                                      ))
Search
Name:
Search
Template glyph key:
action-search
Use case:
Search
 
<span class="ace-icon ace-icon-action-search">Search</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "action-search",_
                                                                                                                        "text", "Search"_
                                                                                                                      ))
Print
Name:
Print
Template glyph key:
action-print
Use case:
Print an item
 
<span class="ace-icon ace-icon-action-print">Print</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "action-print",_
                                                                                                                        "text", "Print"_
                                                                                                                      ))
Remove
Name:
Remove
Template glyph key:
action-remove
Use case:
Remove a document or folder
 
<span class="ace-icon ace-icon-action-remove">Remove</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "action-remove",_
                                                                                                                        "text", "Remove"_
                                                                                                                      ))
Renumber
Name:
Renumber
Template glyph key:
action-renumber
Use case:
Repair numbering (ansarada administrator)
 
<span class="ace-icon ace-icon-action-renumber">Renumber</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "action-renumber",_
                                                                                                                        "text", "Renumber"_
                                                                                                                      ))
Restore
Name:
Restore
Template glyph key:
action-restore
Use case:
Restore documents (ansarada administrator)
 
<span class="ace-icon ace-icon-action-restore">Restore</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "action-restore",_
                                                                                                                        "text", "Restore"_
                                                                                                                      ))

Add

Icon Summary Code
Add attachment
Name:
Add attachment
Template glyph key:
add-attachment
Use case:
Add an attachment
 
<span class="ace-icon ace-icon-add-attachment">Add attachment</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "add-attachment",_
                                                                                                                        "text", "Add attachment"_
                                                                                                                      ))
Add document
Name:
Add document
Template glyph key:
add-document
Use case:
Add a document
 
<span class="ace-icon ace-icon-add-document">Add document</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "add-document",_
                                                                                                                        "text", "Add document"_
                                                                                                                      ))
Add folder
Name:
Add folder
Template glyph key:
add-folder
Use case:
Add a folder
 
<span class="ace-icon ace-icon-add-folder">Add folder</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "add-folder",_
                                                                                                                        "text", "Add folder"_
                                                                                                                      ))
Add generic
Name:
Add generic
Template glyph key:
add-generic
Use case:
Add an item
 
<span class="ace-icon ace-icon-add-generic">Add generic</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "add-generic",_
                                                                                                                        "text", "Add generic"_
                                                                                                                      ))
Add subject
Name:
Add subject
Template glyph key:
add-subject
Use case:
Add a question subject
 
<span class="ace-icon ace-icon-add-subject">Add subject</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "add-subject",_
                                                                                                                        "text", "Add subject"_
                                                                                                                      ))
Add subject group
Name:
Add subject group
Template glyph key:
add-subjectgroup
Use case:
Add a question subject group
 
<span class="ace-icon ace-icon-add-subjectgroup">Add subject group</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "add-subjectgroup",_
                                                                                                                        "text", "Add subject group"_
                                                                                                                      ))
Add security
Name:
Add security
Template glyph key:
add-security
Use case:
Add security to a document or folder
 
<span class="ace-icon ace-icon-add-security">Add security</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "add-security",_
                                                                                                                        "text", "Add security"_
                                                                                                                      ))
Add policy
Name:
Add policy
Template glyph key:
add-policy
Use case:
Add a security policy
 
<span class="ace-icon ace-icon-add-policy">Add policy</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "add-policy",_
                                                                                                                        "text", "Add policy"_
                                                                                                                      ))
Add watermark
Name:
Add watermark
Template glyph key:
add-watermark
Use case:
Add a watermark
 
<span class="ace-icon ace-icon-add-watermark">Add watermark</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "add-watermark",_
                                                                                                                        "text", "Add watermark"_
                                                                                                                      ))
Add buyside
Name:
Add buyside
Template glyph key:
add-buyside
Use case:
Add someone to the buy side
 
<span class="ace-icon ace-icon-add-buyside">Add buyside</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "add-buyside",_
                                                                                                                        "text", "Add buyside"_
                                                                                                                      ))
Add sellside
Name:
Add sellside
Template glyph key:
add-sellside
Use case:
Add someone to the sell side
 
<span class="ace-icon ace-icon-add-sellside">Add sellside</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "add-sellside",_
                                                                                                                        "text", "Add sellside"_
                                                                                                                      ))

Controls

Icon Summary Code
Menu
Name:
Menu
Template glyph key:
control-menu
Use case:
Actions menu. Hamburger or hotdog you choose
 
<span class="ace-icon ace-icon-control-menu">Menu</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "control-menu",_
                                                                                                                        "text", "Menu"_
                                                                                                                      ))
Close
Name:
Close
Template glyph key:
control-close
Use case:
Close or cancel
 
<span class="ace-icon ace-icon-control-close">Close</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "control-close",_
                                                                                                                        "text", "Close"_
                                                                                                                      ))
Filter
Name:
Filter
Template glyph key:
control-filter
Use case:
Filter a set of results, eg. the index element
 
<span class="ace-icon ace-icon-control-filter">Filter</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "control-filter",_
                                                                                                                        "text", "Filter"_
                                                                                                                      ))
Expanded
Name:
Expanded
Template glyph key:
control-expanded
Use case:
Expanded folder
 
<span class="ace-icon ace-icon-control-expanded">Expanded</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "control-expanded",_
                                                                                                                        "text", "Expanded"_
                                                                                                                      ))
Collapsed
Name:
Collapsed
Template glyph key:
control-collapsed
Use case:
Collapsed folder
 
<span class="ace-icon ace-icon-control-collapsed">Collapsed</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "control-collapsed",_
                                                                                                                        "text", "Collapsed"_
                                                                                                                      ))
Arrow down
Name:
Arrow down
Template glyph key:
control-arrowdown
Use case:
Down arrow used to indicate a menu
 
<span class="ace-icon ace-icon-control-arrowdown">Arrow down</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "control-arrowdown",_
                                                                                                                        "text", "Arrow down"_
                                                                                                                      ))
Arrow up
Name:
Arrow up
Template glyph key:
control-arrowup
Use case:
Up arrow
 
<span class="ace-icon ace-icon-control-arrowup">Arrow up</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "control-arrowup",_
                                                                                                                        "text", "Arrow up"_
                                                                                                                      ))
Arrow left
Name:
Arrow left
Template glyph key:
control-arrowleft
Use case:
Left arrow
 
<span class="ace-icon ace-icon-control-arrowleft">Arrow left</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "control-arrowleft",_
                                                                                                                        "text", "Arrow left"_
                                                                                                                      ))
Arrow right
Name:
Arrow right
Template glyph key:
control-arrowright
Use case:
Right arrow
 
<span class="ace-icon ace-icon-control-arrowright">Arrow right</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "control-arrowright",_
                                                                                                                        "text", "Arrow right"_
                                                                                                                      ))
Off
Name:
Off
Template glyph key:
control-off
Use case:
Off indicator (used in toggle)
 
<span class="ace-icon ace-icon-control-off">Off</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "control-off",_
                                                                                                                        "text", "Off"_
                                                                                                                      ))
On
Name:
On
Template glyph key:
control-on
Use case:
On indicator (used in toggle)
 
<span class="ace-icon ace-icon-control-on">On</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "control-on",_
                                                                                                                        "text", "On"_
                                                                                                                      ))
Close
Name:
Close
Template glyph key:
control-closesmall
Use case:
Small version of the icon, used within lozenges to close and form fields to clear information
 
<span class="ace-icon ace-icon-control-closesmall">Close</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "control-closesmall",_
                                                                                                                        "text", "Close"_
                                                                                                                      ))

Documents

Icon Summary Code
Acrobat
Name:
Acrobat
Template glyph key:
document-acrobat
Use case:
Acrobat files and templates
 
<span class="ace-icon ace-icon-document-acrobat">Acrobat</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "document-acrobat",_
                                                                                                                        "text", "Acrobat"_
                                                                                                                      ))
Archive
Name:
Archive
Template glyph key:
document-archive
Use case:
Compressed archives
 
<span class="ace-icon ace-icon-document-archive">Archive</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "document-archive",_
                                                                                                                        "text", "Archive"_
                                                                                                                      ))
Audio
Name:
Audio
Template glyph key:
document-audio
Use case:
Audio files
 
<span class="ace-icon ace-icon-document-audio">Audio</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "document-audio",_
                                                                                                                        "text", "Audio"_
                                                                                                                      ))
Code
Name:
Code
Template glyph key:
document-code
Use case:
Code or source files
 
<span class="ace-icon ace-icon-document-code">Code</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "document-code",_
                                                                                                                        "text", "Code"_
                                                                                                                      ))
Contact
Name:
Contact
Template glyph key:
document-contact
Use case:
Contact information files
 
<span class="ace-icon ace-icon-document-contact">Contact</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "document-contact",_
                                                                                                                        "text", "Contact"_
                                                                                                                      ))
Email
Name:
Email
Template glyph key:
document-email
Use case:
Email files
 
<span class="ace-icon ace-icon-document-email">Email</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "document-email",_
                                                                                                                        "text", "Email"_
                                                                                                                      ))
Excel
Name:
Excel
Template glyph key:
document-excel
Use case:
Excel files and templates
 
<span class="ace-icon ace-icon-document-excel">Excel</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "document-excel",_
                                                                                                                        "text", "Excel"_
                                                                                                                      ))
Generic
Name:
Generic
Template glyph key:
document-generic
Use case:
Generic or unknown documents
 
<span class="ace-icon ace-icon-document-generic">Generic</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "document-generic",_
                                                                                                                        "text", "Generic"_
                                                                                                                      ))
Image
Name:
Image
Template glyph key:
document-image
Use case:
Image files
 
<span class="ace-icon ace-icon-document-image">Image</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "document-image",_
                                                                                                                        "text", "Image"_
                                                                                                                      ))
Layout and design
Name:
Layout and design
Template glyph key:
document-layoutanddesign
Use case:
Layout and design files
 
<span class="ace-icon ace-icon-document-layoutanddesign">Layout and design</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "document-layoutanddesign",_
                                                                                                                        "text", "Layout and design"_
                                                                                                                      ))
Powerpoint
Name:
Powerpoint
Template glyph key:
document-powerpoint
Use case:
Powerpoint files and templates
 
<span class="ace-icon ace-icon-document-powerpoint">Powerpoint</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "document-powerpoint",_
                                                                                                                        "text", "Powerpoint"_
                                                                                                                      ))
Text
Name:
Text
Template glyph key:
document-text
Use case:
Rich and plain text files
 
<span class="ace-icon ace-icon-document-text">Text</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "document-text",_
                                                                                                                        "text", "Text"_
                                                                                                                      ))
Video
Name:
Video
Template glyph key:
document-video
Use case:
Video files
 
<span class="ace-icon ace-icon-document-video">Video</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "document-video",_
                                                                                                                        "text", "Video"_
                                                                                                                      ))
Visio
Name:
Visio
Template glyph key:
document-visio
Use case:
Visio files and templates
 
<span class="ace-icon ace-icon-document-visio">Visio</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "document-visio",_
                                                                                                                        "text", "Visio"_
                                                                                                                      ))
Word
Name:
Word
Template glyph key:
document-word
Use case:
Word files and templates
 
<span class="ace-icon ace-icon-document-word">Word</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "document-word",_
                                                                                                                        "text", "Word"_
                                                                                                                      ))

Objects

Icon Summary Code
Sellside
Name:
Sellside
Template glyph key:
objects-sellside
Use case:
Sell side person
 
<span class="ace-icon ace-icon-objects-sellside">Sellside</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-sellside",_
                                                                                                                        "text", "Sellside"_
                                                                                                                      ))
Sellside group
Name:
Sellside group
Template glyph key:
objects-sellsidegroup
Use case:
Sell side group
 
<span class="ace-icon ace-icon-objects-sellsidegroup">Sellside group</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-sellsidegroup",_
                                                                                                                        "text", "Sellside group"_
                                                                                                                      ))
Buyside
Name:
Buyside
Template glyph key:
objects-buyside
Use case:
Buy side person
 
<span class="ace-icon ace-icon-objects-buyside">Buyside</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-buyside",_
                                                                                                                        "text", "Buyside"_
                                                                                                                      ))
Buyside group
Name:
Buyside group
Template glyph key:
objects-buysidegroup
Use case:
Buy side group
 
<span class="ace-icon ace-icon-objects-buysidegroup">Buyside group</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-buysidegroup",_
                                                                                                                        "text", "Buyside group"_
                                                                                                                      ))
Administrator
Name:
Administrator
Template glyph key:
objects-administrator
Use case:
Administrator
 
<span class="ace-icon ace-icon-objects-administrator">Administrator</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-administrator",_
                                                                                                                        "text", "Administrator"_
                                                                                                                      ))
Security
Name:
Security
Template glyph key:
objects-security
Use case:
Security
 
<span class="ace-icon ace-icon-objects-security">Security</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-security",_
                                                                                                                        "text", "Security"_
                                                                                                                      ))
Policy
Name:
Policy
Template glyph key:
objects-policy
Use case:
Security policy
 
<span class="ace-icon ace-icon-objects-policy">Policy</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-policy",_
                                                                                                                        "text", "Policy"_
                                                                                                                      ))
Watermark
Name:
Watermark
Template glyph key:
objects-watermark
Use case:
Watermark
 
<span class="ace-icon ace-icon-objects-watermark">Watermark</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-watermark",_
                                                                                                                        "text", "Watermark"_
                                                                                                                      ))
Question
Name:
Question
Template glyph key:
objects-question
Use case:
Question
 
<span class="ace-icon ace-icon-objects-question">Question</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-question",_
                                                                                                                        "text", "Question"_
                                                                                                                      ))
Subject
Name:
Subject
Template glyph key:
objects-subject
Use case:
Question subject
 
<span class="ace-icon ace-icon-objects-subject">Subject</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-subject",_
                                                                                                                        "text", "Subject"_
                                                                                                                      ))
Subject group
Name:
Subject group
Template glyph key:
objects-subjectgroup
Use case:
Question subject group
 
<span class="ace-icon ace-icon-objects-subjectgroup">Subject group</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-subjectgroup",_
                                                                                                                        "text", "Subject group"_
                                                                                                                      ))
Answer
Name:
Answer
Template glyph key:
objects-answer
Use case:
Answer
 
<span class="ace-icon ace-icon-objects-answer">Answer</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-answer",_
                                                                                                                        "text", "Answer"_
                                                                                                                      ))
Submission limits
Name:
Submission limits
Template glyph key:
objects-submissionlimits
Use case:
Submission limits for questions
 
<span class="ace-icon ace-icon-objects-submissionlimits">Submission limits</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-submissionlimits",_
                                                                                                                        "text", "Submission limits"_
                                                                                                                      ))
Report
Name:
Report
Template glyph key:
objects-report
Use case:
Report in HTML format
 
<span class="ace-icon ace-icon-objects-report">Report</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-report",_
                                                                                                                        "text", "Report"_
                                                                                                                      ))
Settings
Name:
Settings
Template glyph key:
objects-settings
Use case:
Administration
 
<span class="ace-icon ace-icon-objects-settings">Settings</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-settings",_
                                                                                                                        "text", "Settings"_
                                                                                                                      ))
Folder
Name:
Folder
Template glyph key:
objects-folder
Use case:
Folder
 
<span class="ace-icon ace-icon-objects-folder">Folder</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-folder",_
                                                                                                                        "text", "Folder"_
                                                                                                                      ))
Empty folder
Name:
Empty folder
Template glyph key:
objects-emptyfolder
Use case:
Empty folder
 
<span class="ace-icon ace-icon-objects-emptyfolder">Empty folder</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-emptyfolder",_
                                                                                                                        "text", "Empty folder"_
                                                                                                                      ))
Date
Name:
Date
Template glyph key:
objects-date
Use case:
Date selection
 
<span class="ace-icon ace-icon-objects-date">Date</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-date",_
                                                                                                                        "text", "Date"_
                                                                                                                      ))
History
Name:
History
Template glyph key:
objects-history
Use case:
History
 
<span class="ace-icon ace-icon-objects-history">History</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-history",_
                                                                                                                        "text", "History"_
                                                                                                                      ))
Language
Name:
Language
Template glyph key:
objects-language
Use case:
Language selection
 
<span class="ace-icon ace-icon-objects-language">Language</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-language",_
                                                                                                                        "text", "Language"_
                                                                                                                      ))
Colour
Name:
Colour
Template glyph key:
objects-colour
Use case:
Colour selection
 
<span class="ace-icon ace-icon-objects-colour">Colour</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-colour",_
                                                                                                                        "text", "Colour"_
                                                                                                                      ))
Cloud
Name:
Cloud
Template glyph key:
objects-cloud
Use case:
Colour selection
 
<span class="ace-icon ace-icon-objects-cloud">Cloud</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-cloud",_
                                                                                                                        "text", "Cloud"_
                                                                                                                      ))
User group
Name:
User group
Template glyph key:
objects-usergroup
Use case:
User group
 
<span class="ace-icon ace-icon-objects-usergroup">User group</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "objects-usergroup",_
                                                                                                                        "text", "User group"_
                                                                                                                      ))

Status

Icon Summary Code
Information
Name:
Information
Template glyph key:
status-information
Use case:
Information message
 
<span class="ace-icon ace-icon-status-information">Information</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "status-information",_
                                                                                                                        "text", "Information"_
                                                                                                                      ))
Success
Name:
Success
Template glyph key:
status-success
Use case:
Success message
 
<span class="ace-icon ace-icon-status-success">Success</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "status-success",_
                                                                                                                        "text", "Success"_
                                                                                                                      ))
Caution
Name:
Caution
Template glyph key:
status-caution
Use case:
Caution message
 
<span class="ace-icon ace-icon-status-caution">Caution</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "status-caution",_
                                                                                                                        "text", "Caution"_
                                                                                                                      ))
status-error
Name:
Error
Template glyph key:
status-error
Use case:
Error message (must always be displayed on Fuchsia)
 
<span class="ace-icon ace-icon-status-error">Error</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "status-error",_
                                                                                                                        "text", "Error"_
                                                                                                                      ))
Help
Name:
Help
Template glyph key:
status-help
Use case:
Help message
 
<span class="ace-icon ace-icon-status-help">Help</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "status-help",_
                                                                                                                        "text", "Help"_
                                                                                                                      ))
Not viewed
Name:
Not viewed
Template glyph key:
status-notviewed
Use case:
Document not viewed
 
<span class="ace-icon ace-icon-status-notviewed">Not viewed</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "status-notviewed",_
                                                                                                                        "text", "Not viewed"_
                                                                                                                      ))
Added
Name:
Added
Template glyph key:
status-added
Use case:
Document added
 
<span class="ace-icon ace-icon-status-added">Added</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "status-added",_
                                                                                                                        "text", "Added"_
                                                                                                                      ))
No
Name:
No
Template glyph key:
status-no
Use case:
Setting is off. Icon aka "Nup".
 
<span class="ace-icon ace-icon-status-no">No</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "status-no",_
                                                                                                                        "text", "No"_
                                                                                                                      ))
Yes
Name:
Yes
Template glyph key:
status-yes
Use case:
Setting is on. Icon aka "Yup".
 
<span class="ace-icon ace-icon-status-yes">Yes</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "status-yes",_
                                                                                                                        "text", "Yes"_
                                                                                                                      ))
Disabled
Name:
Disabled
Template glyph key:
status-disabled
Use case:
Document or folder is disabled
 
<span class="ace-icon ace-icon-status-disabled">Disabled</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "status-disabled",_
                                                                                                                        "text", "Disabled"_
                                                                                                                      ))
Email not sent
Name:
Email not sent
Template glyph key:
status-emailnotsent
Use case:
Invite not sent
 
<span class="ace-icon ace-icon-status-emailnotsent">Email not sent</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "status-emailnotsent",_
                                                                                                                        "text", "Email not sent"_
                                                                                                                      ))
Email sent
Name:
Email sent
Template glyph key:
status-emailsent
Use case:
Invite sent
 
<span class="ace-icon ace-icon-status-emailsent">Email sent</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "status-emailsent",_
                                                                                                                        "text", "Email sent"_
                                                                                                                      ))
Priority low
Name:
Priority low
Template glyph key:
status-prioritylow
Use case:
Low priority
 
<span class="ace-icon ace-icon-status-prioritylow">Priority low</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "status-prioritylow",_
                                                                                                                        "text", "Priority low"_
                                                                                                                      ))
Priority medium
Name:
Priority medium
Template glyph key:
status-prioritymedium
Use case:
Medium priority
 
<span class="ace-icon ace-icon-status-prioritymedium">Priority medium</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "status-prioritymedium",_
                                                                                                                        "text", "Priority medium"_
                                                                                                                      ))
Priority high
Name:
Priority high
Template glyph key:
status-priorityhigh
Use case:
High priority
 
<span class="ace-icon ace-icon-status-priorityhigh">Priority high</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "status-priorityhigh",_
                                                                                                                        "text", "Priority high"_
                                                                                                                      ))
Awaiting action
Name:
Awaiting action
Template glyph key:
status-awaitingaction
Use case:
Awaiting my action
 
<span class="ace-icon ace-icon-status-awaitingaction">Awaiting action</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "status-awaitingaction",_
                                                                                                                        "text", "Awaiting action"_
                                                                                                                      ))
Swatch
Name:
Swatch
Template glyph key:
status-swatch
Use case:
Colour watch for groups
 
<span class="ace-icon ace-icon-status-swatch">Swatch</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "status-swatch",_
                                                                                                                        "text", "Swatch"_
                                                                                                                      ))
Loading
Name:
Loading
Template glyph key:
status-loading
Use case:
Loading (draft)
 
<span class="ace-icon ace-icon-status-loading">Loading</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "status-loading",_
                                                                                                                        "text", "Loading"_
                                                                                                                      ))
Secure
Name:
Secure
Template glyph key:
status-secure
Use case:
A document with locked security
 
<span class="ace-icon ace-icon-status-secure">Secure</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "status-secure",_
                                                                                                                        "text", "Secure"_
                                                                                                                      ))
Unsecure
Name:
Unsecure
Template glyph key:
status-unsecure
Use case:
A document with unlocked security
 
<span class="ace-icon ace-icon-status-unsecure">Unsecure</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "status-unsecure",_
                                                                                                                        "text", "Unsecure"_
                                                                                                                      ))

ACE

Icon Summary Code
ACE menu
Name:
ACE menu
Template glyph key:
acemenu
Use case:
Only used for the menu in ACE documentation
 
<span class="ace-icon ace-icon-acemenu">ACE menu</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "acemenu",_
                                                                                                                        "text", "ACE menu"_
                                                                                                                      ))
ACE close
Name:
ACE close
Template glyph key:
aceclose
Use case:
Only used for closing the menu in ACE documentation
 
<span class="ace-icon ace-icon-aceclose">ACE close</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "aceclose",_
                                                                                                                        "text", "ACE close"_
                                                                                                                      ))
ACE foundation
Name:
ACE foundation
Template glyph key:
acefoundation
Use case:
Only used for the Elements menu item in ACE documentation
 
<span class="ace-icon ace-icon-acefoundation">ACE foundation</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "acefoundation",_
                                                                                                                        "text", "ACE foundation"_
                                                                                                                      ))
ACE element
Name:
ACE element
Template glyph key:
aceelement
Use case:
Only used for the Examples menu item in ACE documentation
 
<span class="ace-icon ace-icon-aceelement">ACE element</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "aceelement",_
                                                                                                                        "text", "ACE element"_
                                                                                                                      ))
ACE examples
Name:
ACE examples
Template glyph key:
aceexamples
Use case:
Only used for the Foundation menu item in ACE documentation
 
<span class="ace-icon ace-icon-aceexamples">ACE examples</span>

                                                                                                                      ace.icon(Array(_
                                                                                                                        "glyph", "aceexamples",_
                                                                                                                        "text", "ACE examples"_
                                                                                                                      ))